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_LAPTOP_EAPD,
 234         ALC883_LENOVO_101E_2ch,
 235         ALC883_LENOVO_NB0763,
 236         ALC888_LENOVO_MS7195_DIG,
 237         ALC888_LENOVO_SKY,
 238         ALC883_HAIER_W66,
 239         ALC888_3ST_HP,
 240         ALC888_6ST_DELL,
 241         ALC883_MITAC,
 242         ALC883_CLEVO_M540R,
 243         ALC883_CLEVO_M720,
 244         ALC883_FUJITSU_PI2515,
 245         ALC888_FUJITSU_XA3530,
 246         ALC883_3ST_6ch_INTEL,
 247         ALC889A_INTEL,
 248         ALC889_INTEL,
 249         ALC888_ASUS_M90V,
 250         ALC888_ASUS_EEE1601,
 251         ALC889A_MB31,
 252         ALC1200_ASUS_P5Q,
 253         ALC883_SONY_VAIO_TT,
 254         ALC882_AUTO,
 255         ALC882_MODEL_LAST,
 256 };
 257
 258 /* for GPIO Poll */
 259 #define GPIO_MASK       0x03
 260
 261 /* extra amp-initialization sequence types */
 262 enum {
 263         ALC_INIT_NONE,
 264         ALC_INIT_DEFAULT,
 265         ALC_INIT_GPIO1,
 266         ALC_INIT_GPIO2,
 267         ALC_INIT_GPIO3,
 268 };
 269
 270 struct alc_mic_route {
 271         hda_nid_t pin;
 272         unsigned char mux_idx;
 273         unsigned char amix_idx;
 274 };
 275
 276 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 277
 278 struct alc_spec {
 279         /* codec parameterization */
 280         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 281         unsigned int num_mixers;
 282         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 283         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 284
 285         const struct hda_verb *init_verbs[10];  /* initialization verbs
 286                                                  * don't forget NULL
 287                                                  * termination!
 288                                                  */
 289         unsigned int num_init_verbs;
 290
 291         char stream_name_analog[32];    /* analog PCM stream */
 292         struct hda_pcm_stream *stream_analog_playback;
 293         struct hda_pcm_stream *stream_analog_capture;
 294         struct hda_pcm_stream *stream_analog_alt_playback;
 295         struct hda_pcm_stream *stream_analog_alt_capture;
 296
 297         char stream_name_digital[32];   /* digital PCM stream */
 298         struct hda_pcm_stream *stream_digital_playback;
 299         struct hda_pcm_stream *stream_digital_capture;
 300
 301         /* playback */
 302         struct hda_multi_out multiout;  /* playback set-up
 303                                          * max_channels, dacs must be set
 304                                          * dig_out_nid and hp_nid are optional
 305                                          */
 306         hda_nid_t alt_dac_nid;
 307         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 308         int dig_out_type;
 309
 310         /* capture */
 311         unsigned int num_adc_nids;
 312         hda_nid_t *adc_nids;
 313         hda_nid_t *capsrc_nids;
 314         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 315
 316         /* capture source */
 317         unsigned int num_mux_defs;
 318         const struct hda_input_mux *input_mux;
 319         unsigned int cur_mux[3];
 320         struct alc_mic_route ext_mic;
 321         struct alc_mic_route int_mic;
 322
 323         /* channel model */
 324         const struct hda_channel_mode *channel_mode;
 325         int num_channel_mode;
 326         int need_dac_fix;
 327         int const_channel_count;
 328         int ext_channel_count;
 329
 330         /* PCM information */
 331         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 332
 333         /* dynamic controls, init_verbs and input_mux */
 334         struct auto_pin_cfg autocfg;
 335         struct snd_array kctls;
 336         struct hda_input_mux private_imux[3];
 337         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 338         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 339         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 340
 341         /* hooks */
 342         void (*init_hook)(struct hda_codec *codec);
 343         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 344 #ifdef CONFIG_SND_HDA_POWER_SAVE
 345         void (*power_hook)(struct hda_codec *codec);
 346 #endif
 347
 348         /* for pin sensing */
 349         unsigned int sense_updated: 1;
 350         unsigned int jack_present: 1;
 351         unsigned int master_sw: 1;
 352         unsigned int auto_mic:1;
 353
 354         /* other flags */
 355         unsigned int no_analog :1; /* digital I/O only */
 356         int init_amp;
 357
 358         /* for virtual master */
 359         hda_nid_t vmaster_nid;
 360 #ifdef CONFIG_SND_HDA_POWER_SAVE
 361         struct hda_loopback_check loopback;
 362 #endif
 363
 364         /* for PLL fix */
 365         hda_nid_t pll_nid;
 366         unsigned int pll_coef_idx, pll_coef_bit;
 367 };
 368
 369 /*
 370  * configuration template - to be copied to the spec instance
 371  */
 372 struct alc_config_preset {
 373         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 374                                              * with spec
 375                                              */
 376         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 377         const struct hda_verb *init_verbs[5];
 378         unsigned int num_dacs;
 379         hda_nid_t *dac_nids;
 380         hda_nid_t dig_out_nid;          /* optional */
 381         hda_nid_t hp_nid;               /* optional */
 382         hda_nid_t *slave_dig_outs;
 383         unsigned int num_adc_nids;
 384         hda_nid_t *adc_nids;
 385         hda_nid_t *capsrc_nids;
 386         hda_nid_t dig_in_nid;
 387         unsigned int num_channel_mode;
 388         const struct hda_channel_mode *channel_mode;
 389         int need_dac_fix;
 390         int const_channel_count;
 391         unsigned int num_mux_defs;
 392         const struct hda_input_mux *input_mux;
 393         void (*unsol_event)(struct hda_codec *, unsigned int);
 394         void (*setup)(struct hda_codec *);
 395         void (*init_hook)(struct hda_codec *);
 396 #ifdef CONFIG_SND_HDA_POWER_SAVE
 397         struct hda_amp_list *loopbacks;
 398         void (*power_hook)(struct hda_codec *codec);
 399 #endif
 400 };
 401
 402
 403 /*
 404  * input MUX handling
 405  */
 406 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 407                              struct snd_ctl_elem_info *uinfo)
 408 {
 409         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 410         struct alc_spec *spec = codec->spec;
 411         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 412         if (mux_idx >= spec->num_mux_defs)
 413                 mux_idx = 0;
 414         if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
 415                 mux_idx = 0;
 416         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 417 }
 418
 419 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 420                             struct snd_ctl_elem_value *ucontrol)
 421 {
 422         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 423         struct alc_spec *spec = codec->spec;
 424         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 425
 426         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 427         return 0;
 428 }
 429
 430 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 431                             struct snd_ctl_elem_value *ucontrol)
 432 {
 433         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 434         struct alc_spec *spec = codec->spec;
 435         const struct hda_input_mux *imux;
 436         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 437         unsigned int mux_idx;
 438         hda_nid_t nid = spec->capsrc_nids ?
 439                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 440         unsigned int type;
 441
 442         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 443         imux = &spec->input_mux[mux_idx];
 444         if (!imux->num_items && mux_idx > 0)
 445                 imux = &spec->input_mux[0];
 446
 447         type = get_wcaps_type(get_wcaps(codec, nid));
 448         if (type == AC_WID_AUD_MIX) {
 449                 /* Matrix-mixer style (e.g. ALC882) */
 450                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 451                 unsigned int i, idx;
 452
 453                 idx = ucontrol->value.enumerated.item[0];
 454                 if (idx >= imux->num_items)
 455                         idx = imux->num_items - 1;
 456                 if (*cur_val == idx)
 457                         return 0;
 458                 for (i = 0; i < imux->num_items; i++) {
 459                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 460                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 461                                                  imux->items[i].index,
 462                                                  HDA_AMP_MUTE, v);
 463                 }
 464                 *cur_val = idx;
 465                 return 1;
 466         } else {
 467                 /* MUX style (e.g. ALC880) */
 468                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 469                                              &spec->cur_mux[adc_idx]);
 470         }
 471 }
 472
 473 /*
 474  * channel mode setting
 475  */
 476 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 477                             struct snd_ctl_elem_info *uinfo)
 478 {
 479         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 480         struct alc_spec *spec = codec->spec;
 481         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 482                                     spec->num_channel_mode);
 483 }
 484
 485 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 486                            struct snd_ctl_elem_value *ucontrol)
 487 {
 488         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 489         struct alc_spec *spec = codec->spec;
 490         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 491                                    spec->num_channel_mode,
 492                                    spec->ext_channel_count);
 493 }
 494
 495 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 496                            struct snd_ctl_elem_value *ucontrol)
 497 {
 498         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 499         struct alc_spec *spec = codec->spec;
 500         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 501                                       spec->num_channel_mode,
 502                                       &spec->ext_channel_count);
 503         if (err >= 0 && !spec->const_channel_count) {
 504                 spec->multiout.max_channels = spec->ext_channel_count;
 505                 if (spec->need_dac_fix)
 506                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 507         }
 508         return err;
 509 }
 510
 511 /*
 512  * Control the mode of pin widget settings via the mixer.  "pc" is used
 513  * instead of "%" to avoid consequences of accidently treating the % as
 514  * being part of a format specifier.  Maximum allowed length of a value is
 515  * 63 characters plus NULL terminator.
 516  *
 517  * Note: some retasking pin complexes seem to ignore requests for input
 518  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 519  * are requested.  Therefore order this list so that this behaviour will not
 520  * cause problems when mixer clients move through the enum sequentially.
 521  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 522  * March 2006.
 523  */
 524 static char *alc_pin_mode_names[] = {
 525         "Mic 50pc bias", "Mic 80pc bias",
 526         "Line in", "Line out", "Headphone out",
 527 };
 528 static unsigned char alc_pin_mode_values[] = {
 529         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 530 };
 531 /* The control can present all 5 options, or it can limit the options based
 532  * in the pin being assumed to be exclusively an input or an output pin.  In
 533  * addition, "input" pins may or may not process the mic bias option
 534  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 535  * accept requests for bias as of chip versions up to March 2006) and/or
 536  * wiring in the computer.
 537  */
 538 #define ALC_PIN_DIR_IN              0x00
 539 #define ALC_PIN_DIR_OUT             0x01
 540 #define ALC_PIN_DIR_INOUT           0x02
 541 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 542 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 543
 544 /* Info about the pin modes supported by the different pin direction modes.
 545  * For each direction the minimum and maximum values are given.
 546  */
 547 static signed char alc_pin_mode_dir_info[5][2] = {
 548         { 0, 2 },    /* ALC_PIN_DIR_IN */
 549         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 550         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 551         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 552         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 553 };
 554 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 555 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 556 #define alc_pin_mode_n_items(_dir) \
 557         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 558
 559 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 560                              struct snd_ctl_elem_info *uinfo)
 561 {
 562         unsigned int item_num = uinfo->value.enumerated.item;
 563         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 564
 565         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 566         uinfo->count = 1;
 567         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 568
 569         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 570                 item_num = alc_pin_mode_min(dir);
 571         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 572         return 0;
 573 }
 574
 575 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 576                             struct snd_ctl_elem_value *ucontrol)
 577 {
 578         unsigned int i;
 579         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 580         hda_nid_t nid = kcontrol->private_value & 0xffff;
 581         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 582         long *valp = ucontrol->value.integer.value;
 583         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 584                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 585                                                  0x00);
 586
 587         /* Find enumerated value for current pinctl setting */
 588         i = alc_pin_mode_min(dir);
 589         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 590                 i++;
 591         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 592         return 0;
 593 }
 594
 595 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 596                             struct snd_ctl_elem_value *ucontrol)
 597 {
 598         signed int change;
 599         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 600         hda_nid_t nid = kcontrol->private_value & 0xffff;
 601         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 602         long val = *ucontrol->value.integer.value;
 603         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 604                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 605                                                  0x00);
 606
 607         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 608                 val = alc_pin_mode_min(dir);
 609
 610         change = pinctl != alc_pin_mode_values[val];
 611         if (change) {
 612                 /* Set pin mode to that requested */
 613                 snd_hda_codec_write_cache(codec, nid, 0,
 614                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 615                                           alc_pin_mode_values[val]);
 616
 617                 /* Also enable the retasking pin's input/output as required
 618                  * for the requested pin mode.  Enum values of 2 or less are
 619                  * input modes.
 620                  *
 621                  * Dynamically switching the input/output buffers probably
 622                  * reduces noise slightly (particularly on input) so we'll
 623                  * do it.  However, having both input and output buffers
 624                  * enabled simultaneously doesn't seem to be problematic if
 625                  * this turns out to be necessary in the future.
 626                  */
 627                 if (val <= 2) {
 628                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 629                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 630                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 631                                                  HDA_AMP_MUTE, 0);
 632                 } else {
 633                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 634                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 635                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 636                                                  HDA_AMP_MUTE, 0);
 637                 }
 638         }
 639         return change;
 640 }
 641
 642 #define ALC_PIN_MODE(xname, nid, dir) \
 643         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 644           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 645           .info = alc_pin_mode_info, \
 646           .get = alc_pin_mode_get, \
 647           .put = alc_pin_mode_put, \
 648           .private_value = nid | (dir<<16) }
 649
 650 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 651  * together using a mask with more than one bit set.  This control is
 652  * currently used only by the ALC260 test model.  At this stage they are not
 653  * needed for any "production" models.
 654  */
 655 #ifdef CONFIG_SND_DEBUG
 656 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 657
 658 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 659                              struct snd_ctl_elem_value *ucontrol)
 660 {
 661         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 662         hda_nid_t nid = kcontrol->private_value & 0xffff;
 663         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 664         long *valp = ucontrol->value.integer.value;
 665         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 666                                               AC_VERB_GET_GPIO_DATA, 0x00);
 667
 668         *valp = (val & mask) != 0;
 669         return 0;
 670 }
 671 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 672                              struct snd_ctl_elem_value *ucontrol)
 673 {
 674         signed int change;
 675         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 676         hda_nid_t nid = kcontrol->private_value & 0xffff;
 677         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 678         long val = *ucontrol->value.integer.value;
 679         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 680                                                     AC_VERB_GET_GPIO_DATA,
 681                                                     0x00);
 682
 683         /* Set/unset the masked GPIO bit(s) as needed */
 684         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 685         if (val == 0)
 686                 gpio_data &= ~mask;
 687         else
 688                 gpio_data |= mask;
 689         snd_hda_codec_write_cache(codec, nid, 0,
 690                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 691
 692         return change;
 693 }
 694 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 695         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 696           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 697           .info = alc_gpio_data_info, \
 698           .get = alc_gpio_data_get, \
 699           .put = alc_gpio_data_put, \
 700           .private_value = nid | (mask<<16) }
 701 #endif   /* CONFIG_SND_DEBUG */
 702
 703 /* A switch control to allow the enabling of the digital IO pins on the
 704  * ALC260.  This is incredibly simplistic; the intention of this control is
 705  * to provide something in the test model allowing digital outputs to be
 706  * identified if present.  If models are found which can utilise these
 707  * outputs a more complete mixer control can be devised for those models if
 708  * necessary.
 709  */
 710 #ifdef CONFIG_SND_DEBUG
 711 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 712
 713 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 714                               struct snd_ctl_elem_value *ucontrol)
 715 {
 716         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 717         hda_nid_t nid = kcontrol->private_value & 0xffff;
 718         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 719         long *valp = ucontrol->value.integer.value;
 720         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 721                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 722
 723         *valp = (val & mask) != 0;
 724         return 0;
 725 }
 726 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 727                               struct snd_ctl_elem_value *ucontrol)
 728 {
 729         signed int change;
 730         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 731         hda_nid_t nid = kcontrol->private_value & 0xffff;
 732         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 733         long val = *ucontrol->value.integer.value;
 734         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 735                                                     AC_VERB_GET_DIGI_CONVERT_1,
 736                                                     0x00);
 737
 738         /* Set/unset the masked control bit(s) as needed */
 739         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 740         if (val==0)
 741                 ctrl_data &= ~mask;
 742         else
 743                 ctrl_data |= mask;
 744         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 745                                   ctrl_data);
 746
 747         return change;
 748 }
 749 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 750         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 751           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 752           .info = alc_spdif_ctrl_info, \
 753           .get = alc_spdif_ctrl_get, \
 754           .put = alc_spdif_ctrl_put, \
 755           .private_value = nid | (mask<<16) }
 756 #endif   /* CONFIG_SND_DEBUG */
 757
 758 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 759  * Again, this is only used in the ALC26x test models to help identify when
 760  * the EAPD line must be asserted for features to work.
 761  */
 762 #ifdef CONFIG_SND_DEBUG
 763 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 764
 765 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 766                               struct snd_ctl_elem_value *ucontrol)
 767 {
 768         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 769         hda_nid_t nid = kcontrol->private_value & 0xffff;
 770         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 771         long *valp = ucontrol->value.integer.value;
 772         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 773                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 774
 775         *valp = (val & mask) != 0;
 776         return 0;
 777 }
 778
 779 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 780                               struct snd_ctl_elem_value *ucontrol)
 781 {
 782         int change;
 783         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 784         hda_nid_t nid = kcontrol->private_value & 0xffff;
 785         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 786         long val = *ucontrol->value.integer.value;
 787         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 788                                                     AC_VERB_GET_EAPD_BTLENABLE,
 789                                                     0x00);
 790
 791         /* Set/unset the masked control bit(s) as needed */
 792         change = (!val ? 0 : mask) != (ctrl_data & mask);
 793         if (!val)
 794                 ctrl_data &= ~mask;
 795         else
 796                 ctrl_data |= mask;
 797         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 798                                   ctrl_data);
 799
 800         return change;
 801 }
 802
 803 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 804         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 805           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 806           .info = alc_eapd_ctrl_info, \
 807           .get = alc_eapd_ctrl_get, \
 808           .put = alc_eapd_ctrl_put, \
 809           .private_value = nid | (mask<<16) }
 810 #endif   /* CONFIG_SND_DEBUG */
 811
 812 /*
 813  * set up the input pin config (depending on the given auto-pin type)
 814  */
 815 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 816                               int auto_pin_type)
 817 {
 818         unsigned int val = PIN_IN;
 819
 820         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 821                 unsigned int pincap;
 822                 pincap = snd_hda_query_pin_caps(codec, nid);
 823                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 824                 if (pincap & AC_PINCAP_VREF_80)
 825                         val = PIN_VREF80;
 826                 else if (pincap & AC_PINCAP_VREF_50)
 827                         val = PIN_VREF50;
 828                 else if (pincap & AC_PINCAP_VREF_100)
 829                         val = PIN_VREF100;
 830                 else if (pincap & AC_PINCAP_VREF_GRD)
 831                         val = PIN_VREFGRD;
 832         }
 833         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 834 }
 835
 836 /*
 837  */
 838 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 839 {
 840         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 841                 return;
 842         spec->mixers[spec->num_mixers++] = mix;
 843 }
 844
 845 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 846 {
 847         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 848                 return;
 849         spec->init_verbs[spec->num_init_verbs++] = verb;
 850 }
 851
 852 /*
 853  * set up from the preset table
 854  */
 855 static void setup_preset(struct hda_codec *codec,
 856                          const struct alc_config_preset *preset)
 857 {
 858         struct alc_spec *spec = codec->spec;
 859         int i;
 860
 861         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 862                 add_mixer(spec, preset->mixers[i]);
 863         spec->cap_mixer = preset->cap_mixer;
 864         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 865              i++)
 866                 add_verb(spec, preset->init_verbs[i]);
 867
 868         spec->channel_mode = preset->channel_mode;
 869         spec->num_channel_mode = preset->num_channel_mode;
 870         spec->need_dac_fix = preset->need_dac_fix;
 871         spec->const_channel_count = preset->const_channel_count;
 872
 873         if (preset->const_channel_count)
 874                 spec->multiout.max_channels = preset->const_channel_count;
 875         else
 876                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 877         spec->ext_channel_count = spec->channel_mode[0].channels;
 878
 879         spec->multiout.num_dacs = preset->num_dacs;
 880         spec->multiout.dac_nids = preset->dac_nids;
 881         spec->multiout.dig_out_nid = preset->dig_out_nid;
 882         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 883         spec->multiout.hp_nid = preset->hp_nid;
 884
 885         spec->num_mux_defs = preset->num_mux_defs;
 886         if (!spec->num_mux_defs)
 887                 spec->num_mux_defs = 1;
 888         spec->input_mux = preset->input_mux;
 889
 890         spec->num_adc_nids = preset->num_adc_nids;
 891         spec->adc_nids = preset->adc_nids;
 892         spec->capsrc_nids = preset->capsrc_nids;
 893         spec->dig_in_nid = preset->dig_in_nid;
 894
 895         spec->unsol_event = preset->unsol_event;
 896         spec->init_hook = preset->init_hook;
 897 #ifdef CONFIG_SND_HDA_POWER_SAVE
 898         spec->power_hook = preset->power_hook;
 899         spec->loopback.amplist = preset->loopbacks;
 900 #endif
 901
 902         if (preset->setup)
 903                 preset->setup(codec);
 904 }
 905
 906 /* Enable GPIO mask and set output */
 907 static struct hda_verb alc_gpio1_init_verbs[] = {
 908         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 909         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 910         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 911         { }
 912 };
 913
 914 static struct hda_verb alc_gpio2_init_verbs[] = {
 915         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 916         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 917         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 918         { }
 919 };
 920
 921 static struct hda_verb alc_gpio3_init_verbs[] = {
 922         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 923         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 924         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 925         { }
 926 };
 927
 928 /*
 929  * Fix hardware PLL issue
 930  * On some codecs, the analog PLL gating control must be off while
 931  * the default value is 1.
 932  */
 933 static void alc_fix_pll(struct hda_codec *codec)
 934 {
 935         struct alc_spec *spec = codec->spec;
 936         unsigned int val;
 937
 938         if (!spec->pll_nid)
 939                 return;
 940         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 941                             spec->pll_coef_idx);
 942         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 943                                  AC_VERB_GET_PROC_COEF, 0);
 944         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 945                             spec->pll_coef_idx);
 946         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 947                             val & ~(1 << spec->pll_coef_bit));
 948 }
 949
 950 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 951                              unsigned int coef_idx, unsigned int coef_bit)
 952 {
 953         struct alc_spec *spec = codec->spec;
 954         spec->pll_nid = nid;
 955         spec->pll_coef_idx = coef_idx;
 956         spec->pll_coef_bit = coef_bit;
 957         alc_fix_pll(codec);
 958 }
 959
 960 static void alc_automute_pin(struct hda_codec *codec)
 961 {
 962         struct alc_spec *spec = codec->spec;
 963         unsigned int nid = spec->autocfg.hp_pins[0];
 964         int i;
 965
 966         if (!nid)
 967                 return;
 968         spec->jack_present = snd_hda_jack_detect(codec, nid);
 969         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
 970                 nid = spec->autocfg.speaker_pins[i];
 971                 if (!nid)
 972                         break;
 973                 snd_hda_codec_write(codec, nid, 0,
 974                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 975                                     spec->jack_present ? 0 : PIN_OUT);
 976         }
 977 }
 978
 979 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
 980                                 hda_nid_t nid)
 981 {
 982         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
 983         int i, nums;
 984
 985         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
 986         for (i = 0; i < nums; i++)
 987                 if (conn[i] == nid)
 988                         return i;
 989         return -1;
 990 }
 991
 992 static void alc_mic_automute(struct hda_codec *codec)
 993 {
 994         struct alc_spec *spec = codec->spec;
 995         struct alc_mic_route *dead, *alive;
 996         unsigned int present, type;
 997         hda_nid_t cap_nid;
 998
 999         if (!spec->auto_mic)
1000                 return;
1001         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1002                 return;
1003         if (snd_BUG_ON(!spec->adc_nids))
1004                 return;
1005
1006         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1007
1008         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1009         if (present) {
1010                 alive = &spec->ext_mic;
1011                 dead = &spec->int_mic;
1012         } else {
1013                 alive = &spec->int_mic;
1014                 dead = &spec->ext_mic;
1015         }
1016
1017         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1018         if (type == AC_WID_AUD_MIX) {
1019                 /* Matrix-mixer style (e.g. ALC882) */
1020                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1021                                          alive->mux_idx,
1022                                          HDA_AMP_MUTE, 0);
1023                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1024                                          dead->mux_idx,
1025                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1026         } else {
1027                 /* MUX style (e.g. ALC880) */
1028                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1029                                           AC_VERB_SET_CONNECT_SEL,
1030                                           alive->mux_idx);
1031         }
1032
1033         /* FIXME: analog mixer */
1034 }
1035
1036 /* unsolicited event for HP jack sensing */
1037 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1038 {
1039         if (codec->vendor_id == 0x10ec0880)
1040                 res >>= 28;
1041         else
1042                 res >>= 26;
1043         switch (res) {
1044         case ALC880_HP_EVENT:
1045                 alc_automute_pin(codec);
1046                 break;
1047         case ALC880_MIC_EVENT:
1048                 alc_mic_automute(codec);
1049                 break;
1050         }
1051 }
1052
1053 static void alc_inithook(struct hda_codec *codec)
1054 {
1055         alc_automute_pin(codec);
1056         alc_mic_automute(codec);
1057 }
1058
1059 /* additional initialization for ALC888 variants */
1060 static void alc888_coef_init(struct hda_codec *codec)
1061 {
1062         unsigned int tmp;
1063
1064         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1065         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1066         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1067         if ((tmp & 0xf0) == 0x20)
1068                 /* alc888S-VC */
1069                 snd_hda_codec_read(codec, 0x20, 0,
1070                                    AC_VERB_SET_PROC_COEF, 0x830);
1071          else
1072                  /* alc888-VB */
1073                  snd_hda_codec_read(codec, 0x20, 0,
1074                                     AC_VERB_SET_PROC_COEF, 0x3030);
1075 }
1076
1077 static void alc889_coef_init(struct hda_codec *codec)
1078 {
1079         unsigned int tmp;
1080
1081         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1082         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1083         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1084         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1085 }
1086
1087 /* turn on/off EAPD control (only if available) */
1088 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1089 {
1090         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1091                 return;
1092         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1093                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1094                                     on ? 2 : 0);
1095 }
1096
1097 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1098 {
1099         unsigned int tmp;
1100
1101         switch (type) {
1102         case ALC_INIT_GPIO1:
1103                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1104                 break;
1105         case ALC_INIT_GPIO2:
1106                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1107                 break;
1108         case ALC_INIT_GPIO3:
1109                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1110                 break;
1111         case ALC_INIT_DEFAULT:
1112                 switch (codec->vendor_id) {
1113                 case 0x10ec0260:
1114                         set_eapd(codec, 0x0f, 1);
1115                         set_eapd(codec, 0x10, 1);
1116                         break;
1117                 case 0x10ec0262:
1118                 case 0x10ec0267:
1119                 case 0x10ec0268:
1120                 case 0x10ec0269:
1121                 case 0x10ec0270:
1122                 case 0x10ec0272:
1123                 case 0x10ec0660:
1124                 case 0x10ec0662:
1125                 case 0x10ec0663:
1126                 case 0x10ec0862:
1127                 case 0x10ec0889:
1128                         set_eapd(codec, 0x14, 1);
1129                         set_eapd(codec, 0x15, 1);
1130                         break;
1131                 }
1132                 switch (codec->vendor_id) {
1133                 case 0x10ec0260:
1134                         snd_hda_codec_write(codec, 0x1a, 0,
1135                                             AC_VERB_SET_COEF_INDEX, 7);
1136                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1137                                                  AC_VERB_GET_PROC_COEF, 0);
1138                         snd_hda_codec_write(codec, 0x1a, 0,
1139                                             AC_VERB_SET_COEF_INDEX, 7);
1140                         snd_hda_codec_write(codec, 0x1a, 0,
1141                                             AC_VERB_SET_PROC_COEF,
1142                                             tmp | 0x2010);
1143                         break;
1144                 case 0x10ec0262:
1145                 case 0x10ec0880:
1146                 case 0x10ec0882:
1147                 case 0x10ec0883:
1148                 case 0x10ec0885:
1149                 case 0x10ec0887:
1150                 case 0x10ec0889:
1151                         alc889_coef_init(codec);
1152                         break;
1153                 case 0x10ec0888:
1154                         alc888_coef_init(codec);
1155                         break;
1156 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
1157                 case 0x10ec0267:
1158                 case 0x10ec0268:
1159                         snd_hda_codec_write(codec, 0x20, 0,
1160                                             AC_VERB_SET_COEF_INDEX, 7);
1161                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1162                                                  AC_VERB_GET_PROC_COEF, 0);
1163                         snd_hda_codec_write(codec, 0x20, 0,
1164                                             AC_VERB_SET_COEF_INDEX, 7);
1165                         snd_hda_codec_write(codec, 0x20, 0,
1166                                             AC_VERB_SET_PROC_COEF,
1167                                             tmp | 0x3000);
1168                         break;
1169 #endif /* XXX */
1170                 }
1171                 break;
1172         }
1173 }
1174
1175 static void alc_init_auto_hp(struct hda_codec *codec)
1176 {
1177         struct alc_spec *spec = codec->spec;
1178
1179         if (!spec->autocfg.hp_pins[0])
1180                 return;
1181
1182         if (!spec->autocfg.speaker_pins[0]) {
1183                 if (spec->autocfg.line_out_pins[0] &&
1184                     spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1185                         spec->autocfg.speaker_pins[0] =
1186                                 spec->autocfg.line_out_pins[0];
1187                 else
1188                         return;
1189         }
1190
1191         snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1192                     spec->autocfg.hp_pins[0]);
1193         snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1194                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1195                                   AC_USRSP_EN | ALC880_HP_EVENT);
1196         spec->unsol_event = alc_sku_unsol_event;
1197 }
1198
1199 static void alc_init_auto_mic(struct hda_codec *codec)
1200 {
1201         struct alc_spec *spec = codec->spec;
1202         struct auto_pin_cfg *cfg = &spec->autocfg;
1203         hda_nid_t fixed, ext;
1204         int i;
1205
1206         /* there must be only two mic inputs exclusively */
1207         for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++)
1208                 if (cfg->input_pins[i])
1209                         return;
1210
1211         fixed = ext = 0;
1212         for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) {
1213                 hda_nid_t nid = cfg->input_pins[i];
1214                 unsigned int defcfg;
1215                 if (!nid)
1216                         return;
1217                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1218                 switch (get_defcfg_connect(defcfg)) {
1219                 case AC_JACK_PORT_FIXED:
1220                         if (fixed)
1221                                 return; /* already occupied */
1222                         fixed = nid;
1223                         break;
1224                 case AC_JACK_PORT_COMPLEX:
1225                         if (ext)
1226                                 return; /* already occupied */
1227                         ext = nid;
1228                         break;
1229                 default:
1230                         return; /* invalid entry */
1231                 }
1232         }
1233         if (!ext || !fixed)
1234                 return;
1235         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1236                 return; /* no unsol support */
1237         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1238                     ext, fixed);
1239         spec->ext_mic.pin = ext;
1240         spec->int_mic.pin = fixed;
1241         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1242         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1243         spec->auto_mic = 1;
1244         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1245                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1246                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1247         spec->unsol_event = alc_sku_unsol_event;
1248 }
1249
1250 /* check subsystem ID and set up device-specific initialization;
1251  * return 1 if initialized, 0 if invalid SSID
1252  */
1253 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1254  *      31 ~ 16 :       Manufacture ID
1255  *      15 ~ 8  :       SKU ID
1256  *      7  ~ 0  :       Assembly ID
1257  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1258  */
1259 static int alc_subsystem_id(struct hda_codec *codec,
1260                             hda_nid_t porta, hda_nid_t porte,
1261                             hda_nid_t portd, hda_nid_t porti)
1262 {
1263         unsigned int ass, tmp, i;
1264         unsigned nid;
1265         struct alc_spec *spec = codec->spec;
1266
1267         ass = codec->subsystem_id & 0xffff;
1268         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1269                 goto do_sku;
1270
1271         /* invalid SSID, check the special NID pin defcfg instead */
1272         /*
1273          * 31~30        : port connectivity
1274          * 29~21        : reserve
1275          * 20           : PCBEEP input
1276          * 19~16        : Check sum (15:1)
1277          * 15~1         : Custom
1278          * 0            : override
1279         */
1280         nid = 0x1d;
1281         if (codec->vendor_id == 0x10ec0260)
1282                 nid = 0x17;
1283         ass = snd_hda_codec_get_pincfg(codec, nid);
1284         snd_printd("realtek: No valid SSID, "
1285                    "checking pincfg 0x%08x for NID 0x%x\n",
1286                    ass, nid);
1287         if (!(ass & 1))
1288                 return 0;
1289         if ((ass >> 30) != 1)   /* no physical connection */
1290                 return 0;
1291
1292         /* check sum */
1293         tmp = 0;
1294         for (i = 1; i < 16; i++) {
1295                 if ((ass >> i) & 1)
1296                         tmp++;
1297         }
1298         if (((ass >> 16) & 0xf) != tmp)
1299                 return 0;
1300 do_sku:
1301         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1302                    ass & 0xffff, codec->vendor_id);
1303         /*
1304          * 0 : override
1305          * 1 :  Swap Jack
1306          * 2 : 0 --> Desktop, 1 --> Laptop
1307          * 3~5 : External Amplifier control
1308          * 7~6 : Reserved
1309         */
1310         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1311         switch (tmp) {
1312         case 1:
1313                 spec->init_amp = ALC_INIT_GPIO1;
1314                 break;
1315         case 3:
1316                 spec->init_amp = ALC_INIT_GPIO2;
1317                 break;
1318         case 7:
1319                 spec->init_amp = ALC_INIT_GPIO3;
1320                 break;
1321         case 5:
1322                 spec->init_amp = ALC_INIT_DEFAULT;
1323                 break;
1324         }
1325
1326         /* is laptop or Desktop and enable the function "Mute internal speaker
1327          * when the external headphone out jack is plugged"
1328          */
1329         if (!(ass & 0x8000))
1330                 return 1;
1331         /*
1332          * 10~8 : Jack location
1333          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1334          * 14~13: Resvered
1335          * 15   : 1 --> enable the function "Mute internal speaker
1336          *              when the external headphone out jack is plugged"
1337          */
1338         if (!spec->autocfg.hp_pins[0]) {
1339                 hda_nid_t nid;
1340                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1341                 if (tmp == 0)
1342                         nid = porta;
1343                 else if (tmp == 1)
1344                         nid = porte;
1345                 else if (tmp == 2)
1346                         nid = portd;
1347                 else if (tmp == 3)
1348                         nid = porti;
1349                 else
1350                         return 1;
1351                 for (i = 0; i < spec->autocfg.line_outs; i++)
1352                         if (spec->autocfg.line_out_pins[i] == nid)
1353                                 return 1;
1354                 spec->autocfg.hp_pins[0] = nid;
1355         }
1356
1357         alc_init_auto_hp(codec);
1358         alc_init_auto_mic(codec);
1359         return 1;
1360 }
1361
1362 static void alc_ssid_check(struct hda_codec *codec,
1363                            hda_nid_t porta, hda_nid_t porte,
1364                            hda_nid_t portd, hda_nid_t porti)
1365 {
1366         if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1367                 struct alc_spec *spec = codec->spec;
1368                 snd_printd("realtek: "
1369                            "Enable default setup for auto mode as fallback\n");
1370                 spec->init_amp = ALC_INIT_DEFAULT;
1371                 alc_init_auto_hp(codec);
1372                 alc_init_auto_mic(codec);
1373         }
1374 }
1375
1376 /*
1377  * Fix-up pin default configurations and add default verbs
1378  */
1379
1380 struct alc_pincfg {
1381         hda_nid_t nid;
1382         u32 val;
1383 };
1384
1385 struct alc_fixup {
1386         const struct alc_pincfg *pins;
1387         const struct hda_verb *verbs;
1388 };
1389
1390 static void alc_pick_fixup(struct hda_codec *codec,
1391                            const struct snd_pci_quirk *quirk,
1392                            const struct alc_fixup *fix)
1393 {
1394         const struct alc_pincfg *cfg;
1395
1396         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1397         if (!quirk)
1398                 return;
1399
1400         fix += quirk->value;
1401         cfg = fix->pins;
1402         if (cfg) {
1403                 for (; cfg->nid; cfg++)
1404                         snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1405         }
1406         if (fix->verbs)
1407                 add_verb(codec->spec, fix->verbs);
1408 }
1409
1410 static int alc_read_coef_idx(struct hda_codec *codec,
1411                         unsigned int coef_idx)
1412 {
1413         unsigned int val;
1414         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1415                                 coef_idx);
1416         val = snd_hda_codec_read(codec, 0x20, 0,
1417                                 AC_VERB_GET_PROC_COEF, 0);
1418         return val;
1419 }
1420
1421 /*
1422  * ALC888
1423  */
1424
1425 /*
1426  * 2ch mode
1427  */
1428 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1429 /* Mic-in jack as mic in */
1430         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1431         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1432 /* Line-in jack as Line in */
1433         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1434         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1435 /* Line-Out as Front */
1436         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1437         { } /* end */
1438 };
1439
1440 /*
1441  * 4ch mode
1442  */
1443 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1444 /* Mic-in jack as mic in */
1445         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1446         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1447 /* Line-in jack as Surround */
1448         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1449         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1450 /* Line-Out as Front */
1451         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1452         { } /* end */
1453 };
1454
1455 /*
1456  * 6ch mode
1457  */
1458 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1459 /* Mic-in jack as CLFE */
1460         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1461         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1462 /* Line-in jack as Surround */
1463         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1464         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1465 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1466         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1467         { } /* end */
1468 };
1469
1470 /*
1471  * 8ch mode
1472  */
1473 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1474 /* Mic-in jack as CLFE */
1475         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1476         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1477 /* Line-in jack as Surround */
1478         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1479         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1480 /* Line-Out as Side */
1481         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1482         { } /* end */
1483 };
1484
1485 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1486         { 2, alc888_4ST_ch2_intel_init },
1487         { 4, alc888_4ST_ch4_intel_init },
1488         { 6, alc888_4ST_ch6_intel_init },
1489         { 8, alc888_4ST_ch8_intel_init },
1490 };
1491
1492 /*
1493  * ALC888 Fujitsu Siemens Amillo xa3530
1494  */
1495
1496 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1497 /* Front Mic: set to PIN_IN (empty by default) */
1498         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1499 /* Connect Internal HP to Front */
1500         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1501         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1502         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1503 /* Connect Bass HP to Front */
1504         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1505         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1506         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1507 /* Connect Line-Out side jack (SPDIF) to Side */
1508         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1509         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1510         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1511 /* Connect Mic jack to CLFE */
1512         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1513         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1514         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1515 /* Connect Line-in jack to Surround */
1516         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1517         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1518         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1519 /* Connect HP out jack to Front */
1520         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1521         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1522         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1523 /* Enable unsolicited event for HP jack and Line-out jack */
1524         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1525         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1526         {}
1527 };
1528
1529 static void alc_automute_amp(struct hda_codec *codec)
1530 {
1531         struct alc_spec *spec = codec->spec;
1532         unsigned int mute;
1533         hda_nid_t nid;
1534         int i;
1535
1536         spec->jack_present = 0;
1537         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1538                 nid = spec->autocfg.hp_pins[i];
1539                 if (!nid)
1540                         break;
1541                 if (snd_hda_jack_detect(codec, nid)) {
1542                         spec->jack_present = 1;
1543                         break;
1544                 }
1545         }
1546
1547         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1548         /* Toggle internal speakers muting */
1549         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1550                 nid = spec->autocfg.speaker_pins[i];
1551                 if (!nid)
1552                         break;
1553                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1554                                          HDA_AMP_MUTE, mute);
1555         }
1556 }
1557
1558 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1559                                          unsigned int res)
1560 {
1561         if (codec->vendor_id == 0x10ec0880)
1562                 res >>= 28;
1563         else
1564                 res >>= 26;
1565         if (res == ALC880_HP_EVENT)
1566                 alc_automute_amp(codec);
1567 }
1568
1569 static void alc889_automute_setup(struct hda_codec *codec)
1570 {
1571         struct alc_spec *spec = codec->spec;
1572
1573         spec->autocfg.hp_pins[0] = 0x15;
1574         spec->autocfg.speaker_pins[0] = 0x14;
1575         spec->autocfg.speaker_pins[1] = 0x16;
1576         spec->autocfg.speaker_pins[2] = 0x17;
1577         spec->autocfg.speaker_pins[3] = 0x19;
1578         spec->autocfg.speaker_pins[4] = 0x1a;
1579 }
1580
1581 static void alc889_intel_init_hook(struct hda_codec *codec)
1582 {
1583         alc889_coef_init(codec);
1584         alc_automute_amp(codec);
1585 }
1586
1587 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1588 {
1589         struct alc_spec *spec = codec->spec;
1590
1591         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1592         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1593         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1594         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1595 }
1596
1597 /*
1598  * ALC888 Acer Aspire 4930G model
1599  */
1600
1601 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1602 /* Front Mic: set to PIN_IN (empty by default) */
1603         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1604 /* Unselect Front Mic by default in input mixer 3 */
1605         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1606 /* Enable unsolicited event for HP jack */
1607         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1608 /* Connect Internal HP to front */
1609         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1610         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1611         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1612 /* Connect HP out to front */
1613         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1614         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1615         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1616         { }
1617 };
1618
1619 /*
1620  * ALC888 Acer Aspire 6530G model
1621  */
1622
1623 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1624 /* Route to built-in subwoofer as well as speakers */
1625         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1626         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1627         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1628         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1629 /* Bias voltage on for external mic port */
1630         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1631 /* Front Mic: set to PIN_IN (empty by default) */
1632         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1633 /* Unselect Front Mic by default in input mixer 3 */
1634         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1635 /* Enable unsolicited event for HP jack */
1636         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1637 /* Enable speaker output */
1638         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1639         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1640         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
1641 /* Enable headphone output */
1642         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1643         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1644         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1645         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
1646         { }
1647 };
1648
1649 /*
1650  * ALC889 Acer Aspire 8930G model
1651  */
1652
1653 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1654 /* Front Mic: set to PIN_IN (empty by default) */
1655         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1656 /* Unselect Front Mic by default in input mixer 3 */
1657         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1658 /* Enable unsolicited event for HP jack */
1659         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1660 /* Connect Internal Front to Front */
1661         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1662         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1663         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1664 /* Connect Internal Rear to Rear */
1665         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1666         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1667         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1668 /* Connect Internal CLFE to CLFE */
1669         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1670         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1671         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1672 /* Connect HP out to Front */
1673         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1674         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1675         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1676 /* Enable all DACs */
1677 /*  DAC DISABLE/MUTE 1? */
1678 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
1679         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
1680         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1681 /*  DAC DISABLE/MUTE 2? */
1682 /*  some bit here disables the other DACs. Init=0x4900 */
1683         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
1684         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1685 /* DMIC fix
1686  * This laptop has a stereo digital microphone. The mics are only 1cm apart
1687  * which makes the stereo useless. However, either the mic or the ALC889
1688  * makes the signal become a difference/sum signal instead of standard
1689  * stereo, which is annoying. So instead we flip this bit which makes the
1690  * codec replicate the sum signal to both channels, turning it into a
1691  * normal mono mic.
1692  */
1693 /*  DMIC_CONTROL? Init value = 0x0001 */
1694         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
1695         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
1696         { }
1697 };
1698
1699 static struct hda_input_mux alc888_2_capture_sources[2] = {
1700         /* Front mic only available on one ADC */
1701         {
1702                 .num_items = 4,
1703                 .items = {
1704                         { "Mic", 0x0 },
1705                         { "Line", 0x2 },
1706                         { "CD", 0x4 },
1707                         { "Front Mic", 0xb },
1708                 },
1709         },
1710         {
1711                 .num_items = 3,
1712                 .items = {
1713                         { "Mic", 0x0 },
1714                         { "Line", 0x2 },
1715                         { "CD", 0x4 },
1716                 },
1717         }
1718 };
1719
1720 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
1721         /* Interal mic only available on one ADC */
1722         {
1723                 .num_items = 5,
1724                 .items = {
1725                         { "Ext Mic", 0x0 },
1726                         { "Line In", 0x2 },
1727                         { "CD", 0x4 },
1728                         { "Input Mix", 0xa },
1729                         { "Int Mic", 0xb },
1730                 },
1731         },
1732         {
1733                 .num_items = 4,
1734                 .items = {
1735                         { "Ext Mic", 0x0 },
1736                         { "Line In", 0x2 },
1737                         { "CD", 0x4 },
1738                         { "Input Mix", 0xa },
1739                 },
1740         }
1741 };
1742
1743 static struct hda_input_mux alc889_capture_sources[3] = {
1744         /* Digital mic only available on first "ADC" */
1745         {
1746                 .num_items = 5,
1747                 .items = {
1748                         { "Mic", 0x0 },
1749                         { "Line", 0x2 },
1750                         { "CD", 0x4 },
1751                         { "Front Mic", 0xb },
1752                         { "Input Mix", 0xa },
1753                 },
1754         },
1755         {
1756                 .num_items = 4,
1757                 .items = {
1758                         { "Mic", 0x0 },
1759                         { "Line", 0x2 },
1760                         { "CD", 0x4 },
1761                         { "Input Mix", 0xa },
1762                 },
1763         },
1764         {
1765                 .num_items = 4,
1766                 .items = {
1767                         { "Mic", 0x0 },
1768                         { "Line", 0x2 },
1769                         { "CD", 0x4 },
1770                         { "Input Mix", 0xa },
1771                 },
1772         }
1773 };
1774
1775 static struct snd_kcontrol_new alc888_base_mixer[] = {
1776         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1777         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1778         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1779         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1780         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1781                 HDA_OUTPUT),
1782         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1783         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1784         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1785         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1786         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1787         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1788         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1789         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1790         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1791         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1792         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1793         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1794         { } /* end */
1795 };
1796
1797 static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
1798         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1799         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1800         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1801         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1802         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1803                 HDA_OUTPUT),
1804         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1805         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1806         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1807         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1808         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1809         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1810         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1811         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1812         { } /* end */
1813 };
1814
1815
1816 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
1817 {
1818         struct alc_spec *spec = codec->spec;
1819
1820         spec->autocfg.hp_pins[0] = 0x15;
1821         spec->autocfg.speaker_pins[0] = 0x14;
1822         spec->autocfg.speaker_pins[1] = 0x16;
1823         spec->autocfg.speaker_pins[2] = 0x17;
1824 }
1825
1826 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
1827 {
1828         struct alc_spec *spec = codec->spec;
1829
1830         spec->autocfg.hp_pins[0] = 0x15;
1831         spec->autocfg.speaker_pins[0] = 0x14;
1832         spec->autocfg.speaker_pins[1] = 0x16;
1833         spec->autocfg.speaker_pins[2] = 0x17;
1834 }
1835
1836 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
1837 {
1838         struct alc_spec *spec = codec->spec;
1839
1840         spec->autocfg.hp_pins[0] = 0x15;
1841         spec->autocfg.speaker_pins[0] = 0x14;
1842         spec->autocfg.speaker_pins[1] = 0x16;
1843         spec->autocfg.speaker_pins[2] = 0x1b;
1844 }
1845
1846 /*
1847  * ALC880 3-stack model
1848  *
1849  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1850  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1851  *                 F-Mic = 0x1b, HP = 0x19
1852  */
1853
1854 static hda_nid_t alc880_dac_nids[4] = {
1855         /* front, rear, clfe, rear_surr */
1856         0x02, 0x05, 0x04, 0x03
1857 };
1858
1859 static hda_nid_t alc880_adc_nids[3] = {
1860         /* ADC0-2 */
1861         0x07, 0x08, 0x09,
1862 };
1863
1864 /* The datasheet says the node 0x07 is connected from inputs,
1865  * but it shows zero connection in the real implementation on some devices.
1866  * Note: this is a 915GAV bug, fixed on 915GLV
1867  */
1868 static hda_nid_t alc880_adc_nids_alt[2] = {
1869         /* ADC1-2 */
1870         0x08, 0x09,
1871 };
1872
1873 #define ALC880_DIGOUT_NID       0x06
1874 #define ALC880_DIGIN_NID        0x0a
1875
1876 static struct hda_input_mux alc880_capture_source = {
1877         .num_items = 4,
1878         .items = {
1879                 { "Mic", 0x0 },
1880                 { "Front Mic", 0x3 },
1881                 { "Line", 0x2 },
1882                 { "CD", 0x4 },
1883         },
1884 };
1885
1886 /* channel source setting (2/6 channel selection for 3-stack) */
1887 /* 2ch mode */
1888 static struct hda_verb alc880_threestack_ch2_init[] = {
1889         /* set line-in to input, mute it */
1890         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1891         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1892         /* set mic-in to input vref 80%, mute it */
1893         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1894         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1895         { } /* end */
1896 };
1897
1898 /* 6ch mode */
1899 static struct hda_verb alc880_threestack_ch6_init[] = {
1900         /* set line-in to output, unmute it */
1901         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1902         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1903         /* set mic-in to output, unmute it */
1904         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1905         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1906         { } /* end */
1907 };
1908
1909 static struct hda_channel_mode alc880_threestack_modes[2] = {
1910         { 2, alc880_threestack_ch2_init },
1911         { 6, alc880_threestack_ch6_init },
1912 };
1913
1914 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1915         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1916         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1917         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1918         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1919         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1920         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1921         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1922         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1923         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1924         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1925         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1926         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1927         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1928         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1929         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1930         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1931         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1932         {
1933                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1934                 .name = "Channel Mode",
1935                 .info = alc_ch_mode_info,
1936                 .get = alc_ch_mode_get,
1937                 .put = alc_ch_mode_put,
1938         },
1939         { } /* end */
1940 };
1941
1942 /* capture mixer elements */
1943 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1944                             struct snd_ctl_elem_info *uinfo)
1945 {
1946         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1947         struct alc_spec *spec = codec->spec;
1948         int err;
1949
1950         mutex_lock(&codec->control_mutex);
1951         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1952                                                       HDA_INPUT);
1953         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1954         mutex_unlock(&codec->control_mutex);
1955         return err;
1956 }
1957
1958 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1959                            unsigned int size, unsigned int __user *tlv)
1960 {
1961         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1962         struct alc_spec *spec = codec->spec;
1963         int err;
1964
1965         mutex_lock(&codec->control_mutex);
1966         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1967                                                       HDA_INPUT);
1968         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1969         mutex_unlock(&codec->control_mutex);
1970         return err;
1971 }
1972
1973 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1974                              struct snd_ctl_elem_value *ucontrol);
1975
1976 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1977                                  struct snd_ctl_elem_value *ucontrol,
1978                                  getput_call_t func)
1979 {
1980         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1981         struct alc_spec *spec = codec->spec;
1982         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1983         int err;
1984
1985         mutex_lock(&codec->control_mutex);
1986         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1987                                                       3, 0, HDA_INPUT);
1988         err = func(kcontrol, ucontrol);
1989         mutex_unlock(&codec->control_mutex);
1990         return err;
1991 }
1992
1993 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1994                            struct snd_ctl_elem_value *ucontrol)
1995 {
1996         return alc_cap_getput_caller(kcontrol, ucontrol,
1997                                      snd_hda_mixer_amp_volume_get);
1998 }
1999
2000 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2001                            struct snd_ctl_elem_value *ucontrol)
2002 {
2003         return alc_cap_getput_caller(kcontrol, ucontrol,
2004                                      snd_hda_mixer_amp_volume_put);
2005 }
2006
2007 /* capture mixer elements */
2008 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2009
2010 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2011                           struct snd_ctl_elem_value *ucontrol)
2012 {
2013         return alc_cap_getput_caller(kcontrol, ucontrol,
2014                                      snd_hda_mixer_amp_switch_get);
2015 }
2016
2017 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2018                           struct snd_ctl_elem_value *ucontrol)
2019 {
2020         return alc_cap_getput_caller(kcontrol, ucontrol,
2021                                      snd_hda_mixer_amp_switch_put);
2022 }
2023
2024 #define _DEFINE_CAPMIX(num) \
2025         { \
2026                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2027                 .name = "Capture Switch", \
2028                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2029                 .count = num, \
2030                 .info = alc_cap_sw_info, \
2031                 .get = alc_cap_sw_get, \
2032                 .put = alc_cap_sw_put, \
2033         }, \
2034         { \
2035                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2036                 .name = "Capture Volume", \
2037                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2038                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2039                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2040                 .count = num, \
2041                 .info = alc_cap_vol_info, \
2042                 .get = alc_cap_vol_get, \
2043                 .put = alc_cap_vol_put, \
2044                 .tlv = { .c = alc_cap_vol_tlv }, \
2045         }
2046
2047 #define _DEFINE_CAPSRC(num) \
2048         { \
2049                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2050                 /* .name = "Capture Source", */ \
2051                 .name = "Input Source", \
2052                 .count = num, \
2053                 .info = alc_mux_enum_info, \
2054                 .get = alc_mux_enum_get, \
2055                 .put = alc_mux_enum_put, \
2056         }
2057
2058 #define DEFINE_CAPMIX(num) \
2059 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2060         _DEFINE_CAPMIX(num),                                  \
2061         _DEFINE_CAPSRC(num),                                  \
2062         { } /* end */                                         \
2063 }
2064
2065 #define DEFINE_CAPMIX_NOSRC(num) \
2066 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2067         _DEFINE_CAPMIX(num),                                        \
2068         { } /* end */                                               \
2069 }
2070
2071 /* up to three ADCs */
2072 DEFINE_CAPMIX(1);
2073 DEFINE_CAPMIX(2);
2074 DEFINE_CAPMIX(3);
2075 DEFINE_CAPMIX_NOSRC(1);
2076 DEFINE_CAPMIX_NOSRC(2);
2077 DEFINE_CAPMIX_NOSRC(3);
2078
2079 /*
2080  * ALC880 5-stack model
2081  *
2082  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2083  *      Side = 0x02 (0xd)
2084  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2085  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2086  */
2087
2088 /* additional mixers to alc880_three_stack_mixer */
2089 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2090         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2091         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2092         { } /* end */
2093 };
2094
2095 /* channel source setting (6/8 channel selection for 5-stack) */
2096 /* 6ch mode */
2097 static struct hda_verb alc880_fivestack_ch6_init[] = {
2098         /* set line-in to input, mute it */
2099         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2100         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2101         { } /* end */
2102 };
2103
2104 /* 8ch mode */
2105 static struct hda_verb alc880_fivestack_ch8_init[] = {
2106         /* set line-in to output, unmute it */
2107         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2108         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2109         { } /* end */
2110 };
2111
2112 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2113         { 6, alc880_fivestack_ch6_init },
2114         { 8, alc880_fivestack_ch8_init },
2115 };
2116
2117
2118 /*
2119  * ALC880 6-stack model
2120  *
2121  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2122  *      Side = 0x05 (0x0f)
2123  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2124  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2125  */
2126
2127 static hda_nid_t alc880_6st_dac_nids[4] = {
2128         /* front, rear, clfe, rear_surr */
2129         0x02, 0x03, 0x04, 0x05
2130 };
2131
2132 static struct hda_input_mux alc880_6stack_capture_source = {
2133         .num_items = 4,
2134         .items = {
2135                 { "Mic", 0x0 },
2136                 { "Front Mic", 0x1 },
2137                 { "Line", 0x2 },
2138                 { "CD", 0x4 },
2139         },
2140 };
2141
2142 /* fixed 8-channels */
2143 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2144         { 8, NULL },
2145 };
2146
2147 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2148         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2149         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2150         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2151         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2152         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2153         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2154         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2155         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2156         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2157         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2158         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2159         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2160         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2161         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2162         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2163         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2164         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2165         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2166         {
2167                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2168                 .name = "Channel Mode",
2169                 .info = alc_ch_mode_info,
2170                 .get = alc_ch_mode_get,
2171                 .put = alc_ch_mode_put,
2172         },
2173         { } /* end */
2174 };
2175
2176
2177 /*
2178  * ALC880 W810 model
2179  *
2180  * W810 has rear IO for:
2181  * Front (DAC 02)
2182  * Surround (DAC 03)
2183  * Center/LFE (DAC 04)
2184  * Digital out (06)
2185  *
2186  * The system also has a pair of internal speakers, and a headphone jack.
2187  * These are both connected to Line2 on the codec, hence to DAC 02.
2188  *
2189  * There is a variable resistor to control the speaker or headphone
2190  * volume. This is a hardware-only device without a software API.
2191  *
2192  * Plugging headphones in will disable the internal speakers. This is
2193  * implemented in hardware, not via the driver using jack sense. In
2194  * a similar fashion, plugging into the rear socket marked "front" will
2195  * disable both the speakers and headphones.
2196  *
2197  * For input, there's a microphone jack, and an "audio in" jack.
2198  * These may not do anything useful with this driver yet, because I
2199  * haven't setup any initialization verbs for these yet...
2200  */
2201
2202 static hda_nid_t alc880_w810_dac_nids[3] = {
2203         /* front, rear/surround, clfe */
2204         0x02, 0x03, 0x04
2205 };
2206
2207 /* fixed 6 channels */
2208 static struct hda_channel_mode alc880_w810_modes[1] = {
2209         { 6, NULL }
2210 };
2211
2212 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2213 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2214         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2215         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2216         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2217         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2218         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2219         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2220         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2221         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2222         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2223         { } /* end */
2224 };
2225
2226
2227 /*
2228  * Z710V model
2229  *
2230  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2231  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2232  *                 Line = 0x1a
2233  */
2234
2235 static hda_nid_t alc880_z71v_dac_nids[1] = {
2236         0x02
2237 };
2238 #define ALC880_Z71V_HP_DAC      0x03
2239
2240 /* fixed 2 channels */
2241 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2242         { 2, NULL }
2243 };
2244
2245 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2246         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2247         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2248         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2249         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2250         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2251         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2252         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2253         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2254         { } /* end */
2255 };
2256
2257
2258 /*
2259  * ALC880 F1734 model
2260  *
2261  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2262  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2263  */
2264
2265 static hda_nid_t alc880_f1734_dac_nids[1] = {
2266         0x03
2267 };
2268 #define ALC880_F1734_HP_DAC     0x02
2269
2270 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2271         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2272         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2273         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2274         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2275         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2276         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2277         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2278         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2279         { } /* end */
2280 };
2281
2282 static struct hda_input_mux alc880_f1734_capture_source = {
2283         .num_items = 2,
2284         .items = {
2285                 { "Mic", 0x1 },
2286                 { "CD", 0x4 },
2287         },
2288 };
2289
2290
2291 /*
2292  * ALC880 ASUS model
2293  *
2294  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2295  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2296  *  Mic = 0x18, Line = 0x1a
2297  */
2298
2299 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2300 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2301
2302 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2303         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2304         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2305         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2306         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2307         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2308         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2309         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2310         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2311         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2312         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2313         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2314         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2315         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2316         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2317         {
2318                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2319                 .name = "Channel Mode",
2320                 .info = alc_ch_mode_info,
2321                 .get = alc_ch_mode_get,
2322                 .put = alc_ch_mode_put,
2323         },
2324         { } /* end */
2325 };
2326
2327 /*
2328  * ALC880 ASUS W1V model
2329  *
2330  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2331  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2332  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2333  */
2334
2335 /* additional mixers to alc880_asus_mixer */
2336 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2337         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2338         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2339         { } /* end */
2340 };
2341
2342 /* TCL S700 */
2343 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2344         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2345         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2346         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2347         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2348         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2349         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2350         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2351         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2352         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2353         { } /* end */
2354 };
2355
2356 /* Uniwill */
2357 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2358         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2359         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2360         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2361         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2362         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2363         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2364         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2365         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2366         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2367         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2368         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2369         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2370         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2371         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2372         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2373         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2374         {
2375                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2376                 .name = "Channel Mode",
2377                 .info = alc_ch_mode_info,
2378                 .get = alc_ch_mode_get,
2379                 .put = alc_ch_mode_put,
2380         },
2381         { } /* end */
2382 };
2383
2384 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2385         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2386         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2387         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2388         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2389         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2390         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2391         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2392         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2393         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2394         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2395         { } /* end */
2396 };
2397
2398 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2399         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2400         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2401         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2402         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2403         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2404         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2405         { } /* end */
2406 };
2407
2408 /*
2409  * virtual master controls
2410  */
2411
2412 /*
2413  * slave controls for virtual master
2414  */
2415 static const char *alc_slave_vols[] = {
2416         "Front Playback Volume",
2417         "Surround Playback Volume",
2418         "Center Playback Volume",
2419         "LFE Playback Volume",
2420         "Side Playback Volume",
2421         "Headphone Playback Volume",
2422         "Speaker Playback Volume",
2423         "Mono Playback Volume",
2424         "Line-Out Playback Volume",
2425         "PCM Playback Volume",
2426         NULL,
2427 };
2428
2429 static const char *alc_slave_sws[] = {
2430         "Front Playback Switch",
2431         "Surround Playback Switch",
2432         "Center Playback Switch",
2433         "LFE Playback Switch",
2434         "Side Playback Switch",
2435         "Headphone Playback Switch",
2436         "Speaker Playback Switch",
2437         "Mono Playback Switch",
2438         "IEC958 Playback Switch",
2439         "Line-Out Playback Switch",
2440         "PCM Playback Switch",
2441         NULL,
2442 };
2443
2444 /*
2445  * build control elements
2446  */
2447
2448 #define NID_MAPPING             (-1)
2449
2450 #define SUBDEV_SPEAKER_         (0 << 6)
2451 #define SUBDEV_HP_              (1 << 6)
2452 #define SUBDEV_LINE_            (2 << 6)
2453 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
2454 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
2455 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
2456
2457 static void alc_free_kctls(struct hda_codec *codec);
2458
2459 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2460 /* additional beep mixers; the actual parameters are overwritten at build */
2461 static struct snd_kcontrol_new alc_beep_mixer[] = {
2462         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2463         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2464         { } /* end */
2465 };
2466 #endif
2467
2468 static int alc_build_controls(struct hda_codec *codec)
2469 {
2470         struct alc_spec *spec = codec->spec;
2471         struct snd_kcontrol *kctl;
2472         struct snd_kcontrol_new *knew;
2473         int i, j, err;
2474         unsigned int u;
2475         hda_nid_t nid;
2476
2477         for (i = 0; i < spec->num_mixers; i++) {
2478                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2479                 if (err < 0)
2480                         return err;
2481         }
2482         if (spec->cap_mixer) {
2483                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2484                 if (err < 0)
2485                         return err;
2486         }
2487         if (spec->multiout.dig_out_nid) {
2488                 err = snd_hda_create_spdif_out_ctls(codec,
2489                                                     spec->multiout.dig_out_nid);
2490                 if (err < 0)
2491                         return err;
2492                 if (!spec->no_analog) {
2493                         err = snd_hda_create_spdif_share_sw(codec,
2494                                                             &spec->multiout);
2495                         if (err < 0)
2496                                 return err;
2497                         spec->multiout.share_spdif = 1;
2498                 }
2499         }
2500         if (spec->dig_in_nid) {
2501                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2502                 if (err < 0)
2503                         return err;
2504         }
2505
2506 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2507         /* create beep controls if needed */
2508         if (spec->beep_amp) {
2509                 struct snd_kcontrol_new *knew;
2510                 for (knew = alc_beep_mixer; knew->name; knew++) {
2511                         struct snd_kcontrol *kctl;
2512                         kctl = snd_ctl_new1(knew, codec);
2513                         if (!kctl)
2514                                 return -ENOMEM;
2515                         kctl->private_value = spec->beep_amp;
2516                         err = snd_hda_ctl_add(codec, 0, kctl);
2517                         if (err < 0)
2518                                 return err;
2519                 }
2520         }
2521 #endif
2522
2523         /* if we have no master control, let's create it */
2524         if (!spec->no_analog &&
2525             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2526                 unsigned int vmaster_tlv[4];
2527                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2528                                         HDA_OUTPUT, vmaster_tlv);
2529                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2530                                           vmaster_tlv, alc_slave_vols);
2531                 if (err < 0)
2532                         return err;
2533         }
2534         if (!spec->no_analog &&
2535             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2536                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2537                                           NULL, alc_slave_sws);
2538                 if (err < 0)
2539                         return err;
2540         }
2541
2542         /* assign Capture Source enums to NID */
2543         kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
2544         if (!kctl)
2545                 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
2546         for (i = 0; kctl && i < kctl->count; i++) {
2547                 hda_nid_t *nids = spec->capsrc_nids;
2548                 if (!nids)
2549                         nids = spec->adc_nids;
2550                 err = snd_hda_add_nid(codec, kctl, i, nids[i]);
2551                 if (err < 0)
2552                         return err;
2553         }
2554         if (spec->cap_mixer) {
2555                 const char *kname = kctl ? kctl->id.name : NULL;
2556                 for (knew = spec->cap_mixer; knew->name; knew++) {
2557                         if (kname && strcmp(knew->name, kname) == 0)
2558                                 continue;
2559                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2560                         for (i = 0; kctl && i < kctl->count; i++) {
2561                                 err = snd_hda_add_nid(codec, kctl, i,
2562                                                       spec->adc_nids[i]);
2563                                 if (err < 0)
2564                                         return err;
2565                         }
2566                 }
2567         }
2568
2569         /* other nid->control mapping */
2570         for (i = 0; i < spec->num_mixers; i++) {
2571                 for (knew = spec->mixers[i]; knew->name; knew++) {
2572                         if (knew->iface != NID_MAPPING)
2573                                 continue;
2574                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2575                         if (kctl == NULL)
2576                                 continue;
2577                         u = knew->subdevice;
2578                         for (j = 0; j < 4; j++, u >>= 8) {
2579                                 nid = u & 0x3f;
2580                                 if (nid == 0)
2581                                         continue;
2582                                 switch (u & 0xc0) {
2583                                 case SUBDEV_SPEAKER_:
2584                                         nid = spec->autocfg.speaker_pins[nid];
2585                                         break;
2586                                 case SUBDEV_LINE_:
2587                                         nid = spec->autocfg.line_out_pins[nid];
2588                                         break;
2589                                 case SUBDEV_HP_:
2590                                         nid = spec->autocfg.hp_pins[nid];
2591                                         break;
2592                                 default:
2593                                         continue;
2594                                 }
2595                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2596                                 if (err < 0)
2597                                         return err;
2598                         }
2599                         u = knew->private_value;
2600                         for (j = 0; j < 4; j++, u >>= 8) {
2601                                 nid = u & 0xff;
2602                                 if (nid == 0)
2603                                         continue;
2604                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2605                                 if (err < 0)
2606                                         return err;
2607                         }
2608                 }
2609         }
2610
2611         alc_free_kctls(codec); /* no longer needed */
2612
2613         return 0;
2614 }
2615
2616
2617 /*
2618  * initialize the codec volumes, etc
2619  */
2620
2621 /*
2622  * generic initialization of ADC, input mixers and output mixers
2623  */
2624 static struct hda_verb alc880_volume_init_verbs[] = {
2625         /*
2626          * Unmute ADC0-2 and set the default input to mic-in
2627          */
2628         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2629         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2630         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2631         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2632         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2633         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2634
2635         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2636          * mixer widget
2637          * Note: PASD motherboards uses the Line In 2 as the input for front
2638          * panel mic (mic 2)
2639          */
2640         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2641         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2642         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2643         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2644         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2645         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2646         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2647         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2648
2649         /*
2650          * Set up output mixers (0x0c - 0x0f)
2651          */
2652         /* set vol=0 to output mixers */
2653         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2654         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2655         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2656         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2657         /* set up input amps for analog loopback */
2658         /* Amp Indices: DAC = 0, mixer = 1 */
2659         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2660         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2661         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2662         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2663         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2664         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2665         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2666         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2667
2668         { }
2669 };
2670
2671 /*
2672  * 3-stack pin configuration:
2673  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2674  */
2675 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2676         /*
2677          * preset connection lists of input pins
2678          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2679          */
2680         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2681         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2682         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2683
2684         /*
2685          * Set pin mode and muting
2686          */
2687         /* set front pin widgets 0x14 for output */
2688         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2689         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2690         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2691         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2692         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2693         /* Mic2 (as headphone out) for HP output */
2694         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2695         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2696         /* Line In pin widget for input */
2697         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2698         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2699         /* Line2 (as front mic) pin widget for input and vref at 80% */
2700         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2701         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2702         /* CD pin widget for input */
2703         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2704
2705         { }
2706 };
2707
2708 /*
2709  * 5-stack pin configuration:
2710  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2711  * line-in/side = 0x1a, f-mic = 0x1b
2712  */
2713 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2714         /*
2715          * preset connection lists of input pins
2716          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2717          */
2718         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2719         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2720
2721         /*
2722          * Set pin mode and muting
2723          */
2724         /* set pin widgets 0x14-0x17 for output */
2725         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2726         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2727         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2728         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2729         /* unmute pins for output (no gain on this amp) */
2730         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2731         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2732         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2733         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2734
2735         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2736         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2737         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2738         /* Mic2 (as headphone out) for HP output */
2739         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2740         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2741         /* Line In pin widget for input */
2742         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2743         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2744         /* Line2 (as front mic) pin widget for input and vref at 80% */
2745         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2746         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2747         /* CD pin widget for input */
2748         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2749
2750         { }
2751 };
2752
2753 /*
2754  * W810 pin configuration:
2755  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2756  */
2757 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2758         /* hphone/speaker input selector: front DAC */
2759         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2760
2761         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2762         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2763         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2764         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2765         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2766         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2767
2768         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2769         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2770
2771         { }
2772 };
2773
2774 /*
2775  * Z71V pin configuration:
2776  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2777  */
2778 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2779         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2780         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2781         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2782         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2783
2784         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2785         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2786         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2787         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2788
2789         { }
2790 };
2791
2792 /*
2793  * 6-stack pin configuration:
2794  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2795  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2796  */
2797 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2798         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2799
2800         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2801         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2802         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2803         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2804         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2805         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2806         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2807         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2808
2809         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2810         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2811         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2812         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2813         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2814         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2815         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2816         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2817         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2818
2819         { }
2820 };
2821
2822 /*
2823  * Uniwill pin configuration:
2824  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2825  * line = 0x1a
2826  */
2827 static struct hda_verb alc880_uniwill_init_verbs[] = {
2828         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2829
2830         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2831         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2832         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2833         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2834         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2835         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2836         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2837         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2838         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2839         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2840         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2841         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2842         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2843         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2844
2845         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2846         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2847         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2848         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2849         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2850         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2851         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2852         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2853         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2854
2855         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2856         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2857
2858         { }
2859 };
2860
2861 /*
2862 * Uniwill P53
2863 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2864  */
2865 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2866         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2867
2868         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2869         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2870         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2871         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2872         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2873         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2874         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2875         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2876         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2877         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2878         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2879         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2880
2881         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2882         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2883         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2884         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2885         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2886         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2887
2888         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2889         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2890
2891         { }
2892 };
2893
2894 static struct hda_verb alc880_beep_init_verbs[] = {
2895         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2896         { }
2897 };
2898
2899 /* auto-toggle front mic */
2900 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2901 {
2902         unsigned int present;
2903         unsigned char bits;
2904
2905         present = snd_hda_jack_detect(codec, 0x18);
2906         bits = present ? HDA_AMP_MUTE : 0;
2907         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2908 }
2909
2910 static void alc880_uniwill_setup(struct hda_codec *codec)
2911 {
2912         struct alc_spec *spec = codec->spec;
2913
2914         spec->autocfg.hp_pins[0] = 0x14;
2915         spec->autocfg.speaker_pins[0] = 0x15;
2916         spec->autocfg.speaker_pins[0] = 0x16;
2917 }
2918
2919 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2920 {
2921         alc_automute_amp(codec);
2922         alc880_uniwill_mic_automute(codec);
2923 }
2924
2925 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2926                                        unsigned int res)
2927 {
2928         /* Looks like the unsol event is incompatible with the standard
2929          * definition.  4bit tag is placed at 28 bit!
2930          */
2931         switch (res >> 28) {
2932         case ALC880_MIC_EVENT:
2933                 alc880_uniwill_mic_automute(codec);
2934                 break;
2935         default:
2936                 alc_automute_amp_unsol_event(codec, res);
2937                 break;
2938         }
2939 }
2940
2941 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
2942 {
2943         struct alc_spec *spec = codec->spec;
2944
2945         spec->autocfg.hp_pins[0] = 0x14;
2946         spec->autocfg.speaker_pins[0] = 0x15;
2947 }
2948
2949 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2950 {
2951         unsigned int present;
2952
2953         present = snd_hda_codec_read(codec, 0x21, 0,
2954                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2955         present &= HDA_AMP_VOLMASK;
2956         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2957                                  HDA_AMP_VOLMASK, present);
2958         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2959                                  HDA_AMP_VOLMASK, present);
2960 }
2961
2962 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2963                                            unsigned int res)
2964 {
2965         /* Looks like the unsol event is incompatible with the standard
2966          * definition.  4bit tag is placed at 28 bit!
2967          */
2968         if ((res >> 28) == ALC880_DCVOL_EVENT)
2969                 alc880_uniwill_p53_dcvol_automute(codec);
2970         else
2971                 alc_automute_amp_unsol_event(codec, res);
2972 }
2973
2974 /*
2975  * F1734 pin configuration:
2976  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2977  */
2978 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2979         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2980         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2981         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2982         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2983         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2984
2985         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2986         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2987         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2988         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2989
2990         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2991         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2992         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2993         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2994         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2995         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2996         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2997         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2998         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2999
3000         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3001         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3002
3003         { }
3004 };
3005
3006 /*
3007  * ASUS pin configuration:
3008  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3009  */
3010 static struct hda_verb alc880_pin_asus_init_verbs[] = {
3011         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3012         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3013         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3014         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3015
3016         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3017         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3018         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3019         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3020         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3021         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3022         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3023         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3024
3025         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3026         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3027         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3028         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3029         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3030         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3031         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3032         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3033         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3034
3035         { }
3036 };
3037
3038 /* Enable GPIO mask and set output */
3039 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
3040 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
3041 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
3042
3043 /* Clevo m520g init */
3044 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3045         /* headphone output */
3046         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3047         /* line-out */
3048         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3049         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3050         /* Line-in */
3051         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3052         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3053         /* CD */
3054         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3055         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3056         /* Mic1 (rear panel) */
3057         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3058         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3059         /* Mic2 (front panel) */
3060         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3061         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3062         /* headphone */
3063         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3064         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3065         /* change to EAPD mode */
3066         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3067         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3068
3069         { }
3070 };
3071
3072 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3073         /* change to EAPD mode */
3074         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3075         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3076
3077         /* Headphone output */
3078         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3079         /* Front output*/
3080         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3081         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3082
3083         /* Line In pin widget for input */
3084         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3085         /* CD pin widget for input */
3086         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3087         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3088         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3089
3090         /* change to EAPD mode */
3091         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3092         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3093
3094         { }
3095 };
3096
3097 /*
3098  * LG m1 express dual
3099  *
3100  * Pin assignment:
3101  *   Rear Line-In/Out (blue): 0x14
3102  *   Build-in Mic-In: 0x15
3103  *   Speaker-out: 0x17
3104  *   HP-Out (green): 0x1b
3105  *   Mic-In/Out (red): 0x19
3106  *   SPDIF-Out: 0x1e
3107  */
3108
3109 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3110 static hda_nid_t alc880_lg_dac_nids[3] = {
3111         0x05, 0x02, 0x03
3112 };
3113
3114 /* seems analog CD is not working */
3115 static struct hda_input_mux alc880_lg_capture_source = {
3116         .num_items = 3,
3117         .items = {
3118                 { "Mic", 0x1 },
3119                 { "Line", 0x5 },
3120                 { "Internal Mic", 0x6 },
3121         },
3122 };
3123
3124 /* 2,4,6 channel modes */
3125 static struct hda_verb alc880_lg_ch2_init[] = {
3126         /* set line-in and mic-in to input */
3127         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3128         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3129         { }
3130 };
3131
3132 static struct hda_verb alc880_lg_ch4_init[] = {
3133         /* set line-in to out and mic-in to input */
3134         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3135         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3136         { }
3137 };
3138
3139 static struct hda_verb alc880_lg_ch6_init[] = {
3140         /* set line-in and mic-in to output */
3141         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3142         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3143         { }
3144 };
3145
3146 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3147         { 2, alc880_lg_ch2_init },
3148         { 4, alc880_lg_ch4_init },
3149         { 6, alc880_lg_ch6_init },
3150 };
3151
3152 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3153         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3154         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3155         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3156         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3157         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3158         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3159         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3160         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3161         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3162         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3163         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3164         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3165         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3166         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3167         {
3168                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3169                 .name = "Channel Mode",
3170                 .info = alc_ch_mode_info,
3171                 .get = alc_ch_mode_get,
3172                 .put = alc_ch_mode_put,
3173         },
3174         { } /* end */
3175 };
3176
3177 static struct hda_verb alc880_lg_init_verbs[] = {
3178         /* set capture source to mic-in */
3179         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3180         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3181         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3182         /* mute all amp mixer inputs */
3183         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3184         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3185         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3186         /* line-in to input */
3187         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3188         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3189         /* built-in mic */
3190         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3191         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3192         /* speaker-out */
3193         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3194         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3195         /* mic-in to input */
3196         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3197         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3198         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3199         /* HP-out */
3200         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3201         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3202         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3203         /* jack sense */
3204         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3205         { }
3206 };
3207
3208 /* toggle speaker-output according to the hp-jack state */
3209 static void alc880_lg_setup(struct hda_codec *codec)
3210 {
3211         struct alc_spec *spec = codec->spec;
3212
3213         spec->autocfg.hp_pins[0] = 0x1b;
3214         spec->autocfg.speaker_pins[0] = 0x17;
3215 }
3216
3217 /*
3218  * LG LW20
3219  *
3220  * Pin assignment:
3221  *   Speaker-out: 0x14
3222  *   Mic-In: 0x18
3223  *   Built-in Mic-In: 0x19
3224  *   Line-In: 0x1b
3225  *   HP-Out: 0x1a
3226  *   SPDIF-Out: 0x1e
3227  */
3228
3229 static struct hda_input_mux alc880_lg_lw_capture_source = {
3230         .num_items = 3,
3231         .items = {
3232                 { "Mic", 0x0 },
3233                 { "Internal Mic", 0x1 },
3234                 { "Line In", 0x2 },
3235         },
3236 };
3237
3238 #define alc880_lg_lw_modes alc880_threestack_modes
3239
3240 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3241         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3242         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3243         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3244         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3245         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3246         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3247         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3248         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3249         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3250         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3251         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3252         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3253         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3254         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3255         {
3256                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3257                 .name = "Channel Mode",
3258                 .info = alc_ch_mode_info,
3259                 .get = alc_ch_mode_get,
3260                 .put = alc_ch_mode_put,
3261         },
3262         { } /* end */
3263 };
3264
3265 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3266         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3267         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3268         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3269
3270         /* set capture source to mic-in */
3271         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3272         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3273         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3274         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3275         /* speaker-out */
3276         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3277         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3278         /* HP-out */
3279         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3280         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3281         /* mic-in to input */
3282         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3283         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3284         /* built-in mic */
3285         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3286         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3287         /* jack sense */
3288         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3289         { }
3290 };
3291
3292 /* toggle speaker-output according to the hp-jack state */
3293 static void alc880_lg_lw_setup(struct hda_codec *codec)
3294 {
3295         struct alc_spec *spec = codec->spec;
3296
3297         spec->autocfg.hp_pins[0] = 0x1b;
3298         spec->autocfg.speaker_pins[0] = 0x14;
3299 }
3300
3301 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3302         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3303         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3304         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3305         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3306         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3307         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3308         { } /* end */
3309 };
3310
3311 static struct hda_input_mux alc880_medion_rim_capture_source = {
3312         .num_items = 2,
3313         .items = {
3314                 { "Mic", 0x0 },
3315                 { "Internal Mic", 0x1 },
3316         },
3317 };
3318
3319 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3320         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3321
3322         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3323         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3324
3325         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3326         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3327         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3328         /* Mic2 (as headphone out) for HP output */
3329         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3330         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3331         /* Internal Speaker */
3332         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3333         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3334
3335         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3336         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3337
3338         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3339         { }
3340 };
3341
3342 /* toggle speaker-output according to the hp-jack state */
3343 static void alc880_medion_rim_automute(struct hda_codec *codec)
3344 {
3345         struct alc_spec *spec = codec->spec;
3346         alc_automute_amp(codec);
3347         /* toggle EAPD */
3348         if (spec->jack_present)
3349                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3350         else
3351                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3352 }
3353
3354 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3355                                           unsigned int res)
3356 {
3357         /* Looks like the unsol event is incompatible with the standard
3358          * definition.  4bit tag is placed at 28 bit!
3359          */
3360         if ((res >> 28) == ALC880_HP_EVENT)
3361                 alc880_medion_rim_automute(codec);
3362 }
3363
3364 static void alc880_medion_rim_setup(struct hda_codec *codec)
3365 {
3366         struct alc_spec *spec = codec->spec;
3367
3368         spec->autocfg.hp_pins[0] = 0x14;
3369         spec->autocfg.speaker_pins[0] = 0x1b;
3370 }
3371
3372 #ifdef CONFIG_SND_HDA_POWER_SAVE
3373 static struct hda_amp_list alc880_loopbacks[] = {
3374         { 0x0b, HDA_INPUT, 0 },
3375         { 0x0b, HDA_INPUT, 1 },
3376         { 0x0b, HDA_INPUT, 2 },
3377         { 0x0b, HDA_INPUT, 3 },
3378         { 0x0b, HDA_INPUT, 4 },
3379         { } /* end */
3380 };
3381
3382 static struct hda_amp_list alc880_lg_loopbacks[] = {
3383         { 0x0b, HDA_INPUT, 1 },
3384         { 0x0b, HDA_INPUT, 6 },
3385         { 0x0b, HDA_INPUT, 7 },
3386         { } /* end */
3387 };
3388 #endif
3389
3390 /*
3391  * Common callbacks
3392  */
3393
3394 static int alc_init(struct hda_codec *codec)
3395 {
3396         struct alc_spec *spec = codec->spec;
3397         unsigned int i;
3398
3399         alc_fix_pll(codec);
3400         alc_auto_init_amp(codec, spec->init_amp);
3401
3402         for (i = 0; i < spec->num_init_verbs; i++)
3403                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3404
3405         if (spec->init_hook)
3406                 spec->init_hook(codec);
3407
3408         return 0;
3409 }
3410
3411 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3412 {
3413         struct alc_spec *spec = codec->spec;
3414
3415         if (spec->unsol_event)
3416                 spec->unsol_event(codec, res);
3417 }
3418
3419 #ifdef CONFIG_SND_HDA_POWER_SAVE
3420 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3421 {
3422         struct alc_spec *spec = codec->spec;
3423         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3424 }
3425 #endif
3426
3427 /*
3428  * Analog playback callbacks
3429  */
3430 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3431                                     struct hda_codec *codec,
3432                                     struct snd_pcm_substream *substream)
3433 {
3434         struct alc_spec *spec = codec->spec;
3435         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3436                                              hinfo);
3437 }
3438
3439 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3440                                        struct hda_codec *codec,
3441                                        unsigned int stream_tag,
3442                                        unsigned int format,
3443                                        struct snd_pcm_substream *substream)
3444 {
3445         struct alc_spec *spec = codec->spec;
3446         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3447                                                 stream_tag, format, substream);
3448 }
3449
3450 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3451                                        struct hda_codec *codec,
3452                                        struct snd_pcm_substream *substream)
3453 {
3454         struct alc_spec *spec = codec->spec;
3455         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3456 }
3457
3458 /*
3459  * Digital out
3460  */
3461 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3462                                         struct hda_codec *codec,
3463                                         struct snd_pcm_substream *substream)
3464 {
3465         struct alc_spec *spec = codec->spec;
3466         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3467 }
3468
3469 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3470                                            struct hda_codec *codec,
3471                                            unsigned int stream_tag,
3472                                            unsigned int format,
3473                                            struct snd_pcm_substream *substream)
3474 {
3475         struct alc_spec *spec = codec->spec;
3476         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3477                                              stream_tag, format, substream);
3478 }
3479
3480 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3481                                            struct hda_codec *codec,
3482                                            struct snd_pcm_substream *substream)
3483 {
3484         struct alc_spec *spec = codec->spec;
3485         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3486 }
3487
3488 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3489                                          struct hda_codec *codec,
3490                                          struct snd_pcm_substream *substream)
3491 {
3492         struct alc_spec *spec = codec->spec;
3493         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3494 }
3495
3496 /*
3497  * Analog capture
3498  */
3499 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3500                                       struct hda_codec *codec,
3501                                       unsigned int stream_tag,
3502                                       unsigned int format,
3503                                       struct snd_pcm_substream *substream)
3504 {
3505         struct alc_spec *spec = codec->spec;
3506
3507         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3508                                    stream_tag, 0, format);
3509         return 0;
3510 }
3511
3512 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3513                                       struct hda_codec *codec,
3514                                       struct snd_pcm_substream *substream)
3515 {
3516         struct alc_spec *spec = codec->spec;
3517
3518         snd_hda_codec_cleanup_stream(codec,
3519                                      spec->adc_nids[substream->number + 1]);
3520         return 0;
3521 }
3522
3523
3524 /*
3525  */
3526 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3527         .substreams = 1,
3528         .channels_min = 2,
3529         .channels_max = 8,
3530         /* NID is set in alc_build_pcms */
3531         .ops = {
3532                 .open = alc880_playback_pcm_open,
3533                 .prepare = alc880_playback_pcm_prepare,
3534                 .cleanup = alc880_playback_pcm_cleanup
3535         },
3536 };
3537
3538 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3539         .substreams = 1,
3540         .channels_min = 2,
3541         .channels_max = 2,
3542         /* NID is set in alc_build_pcms */
3543 };
3544
3545 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3546         .substreams = 1,
3547         .channels_min = 2,
3548         .channels_max = 2,
3549         /* NID is set in alc_build_pcms */
3550 };
3551
3552 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3553         .substreams = 2, /* can be overridden */
3554         .channels_min = 2,
3555         .channels_max = 2,
3556         /* NID is set in alc_build_pcms */
3557         .ops = {
3558                 .prepare = alc880_alt_capture_pcm_prepare,
3559                 .cleanup = alc880_alt_capture_pcm_cleanup
3560         },
3561 };
3562
3563 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3564         .substreams = 1,
3565         .channels_min = 2,
3566         .channels_max = 2,
3567         /* NID is set in alc_build_pcms */
3568         .ops = {
3569                 .open = alc880_dig_playback_pcm_open,
3570                 .close = alc880_dig_playback_pcm_close,
3571                 .prepare = alc880_dig_playback_pcm_prepare,
3572                 .cleanup = alc880_dig_playback_pcm_cleanup
3573         },
3574 };
3575
3576 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3577         .substreams = 1,
3578         .channels_min = 2,
3579         .channels_max = 2,
3580         /* NID is set in alc_build_pcms */
3581 };
3582
3583 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3584 static struct hda_pcm_stream alc_pcm_null_stream = {
3585         .substreams = 0,
3586         .channels_min = 0,
3587         .channels_max = 0,
3588 };
3589
3590 static int alc_build_pcms(struct hda_codec *codec)
3591 {
3592         struct alc_spec *spec = codec->spec;
3593         struct hda_pcm *info = spec->pcm_rec;
3594         int i;
3595
3596         codec->num_pcms = 1;
3597         codec->pcm_info = info;
3598
3599         if (spec->no_analog)
3600                 goto skip_analog;
3601
3602         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3603                  "%s Analog", codec->chip_name);
3604         info->name = spec->stream_name_analog;
3605
3606         if (spec->stream_analog_playback) {
3607                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3608                         return -EINVAL;
3609                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3610                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3611         }
3612         if (spec->stream_analog_capture) {
3613                 if (snd_BUG_ON(!spec->adc_nids))
3614                         return -EINVAL;
3615                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3616                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3617         }
3618
3619         if (spec->channel_mode) {
3620                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3621                 for (i = 0; i < spec->num_channel_mode; i++) {
3622                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3623                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3624                         }
3625                 }
3626         }
3627
3628  skip_analog:
3629         /* SPDIF for stream index #1 */
3630         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3631                 snprintf(spec->stream_name_digital,
3632                          sizeof(spec->stream_name_digital),
3633                          "%s Digital", codec->chip_name);
3634                 codec->num_pcms = 2;
3635                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3636                 info = spec->pcm_rec + 1;
3637                 info->name = spec->stream_name_digital;
3638                 if (spec->dig_out_type)
3639                         info->pcm_type = spec->dig_out_type;
3640                 else
3641                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3642                 if (spec->multiout.dig_out_nid &&
3643                     spec->stream_digital_playback) {
3644                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3645                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3646                 }
3647                 if (spec->dig_in_nid &&
3648                     spec->stream_digital_capture) {
3649                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3650                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3651                 }
3652                 /* FIXME: do we need this for all Realtek codec models? */
3653                 codec->spdif_status_reset = 1;
3654         }
3655
3656         if (spec->no_analog)
3657                 return 0;
3658
3659         /* If the use of more than one ADC is requested for the current
3660          * model, configure a second analog capture-only PCM.
3661          */
3662         /* Additional Analaog capture for index #2 */
3663         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3664             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3665                 codec->num_pcms = 3;
3666                 info = spec->pcm_rec + 2;
3667                 info->name = spec->stream_name_analog;
3668                 if (spec->alt_dac_nid) {
3669                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3670                                 *spec->stream_analog_alt_playback;
3671                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3672                                 spec->alt_dac_nid;
3673                 } else {
3674                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3675                                 alc_pcm_null_stream;
3676                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3677                 }
3678                 if (spec->num_adc_nids > 1) {
3679                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3680                                 *spec->stream_analog_alt_capture;
3681                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3682                                 spec->adc_nids[1];
3683                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3684                                 spec->num_adc_nids - 1;
3685                 } else {
3686                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3687                                 alc_pcm_null_stream;
3688                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3689                 }
3690         }
3691
3692         return 0;
3693 }
3694
3695 static inline void alc_shutup(struct hda_codec *codec)
3696 {
3697         snd_hda_shutup_pins(codec);
3698 }
3699
3700 static void alc_free_kctls(struct hda_codec *codec)
3701 {
3702         struct alc_spec *spec = codec->spec;
3703
3704         if (spec->kctls.list) {
3705                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3706                 int i;
3707                 for (i = 0; i < spec->kctls.used; i++)
3708                         kfree(kctl[i].name);
3709         }
3710         snd_array_free(&spec->kctls);
3711 }
3712
3713 static void alc_free(struct hda_codec *codec)
3714 {
3715         struct alc_spec *spec = codec->spec;
3716
3717         if (!spec)
3718                 return;
3719
3720         alc_shutup(codec);
3721         alc_free_kctls(codec);
3722         kfree(spec);
3723         snd_hda_detach_beep_device(codec);
3724 }
3725
3726 #ifdef CONFIG_SND_HDA_POWER_SAVE
3727 static void alc_power_eapd(struct hda_codec *codec)
3728 {
3729         /* We currently only handle front, HP */
3730         switch (codec->vendor_id) {
3731         case 0x10ec0260:
3732                 set_eapd(codec, 0x0f, 0);
3733                 set_eapd(codec, 0x10, 0);
3734                 break;
3735         case 0x10ec0262:
3736         case 0x10ec0267:
3737         case 0x10ec0268:
3738         case 0x10ec0269:
3739         case 0x10ec0270:
3740         case 0x10ec0272:
3741         case 0x10ec0660:
3742         case 0x10ec0662:
3743         case 0x10ec0663:
3744         case 0x10ec0862:
3745         case 0x10ec0889:
3746                 set_eapd(codec, 0x14, 0);
3747                 set_eapd(codec, 0x15, 0);
3748                 break;
3749         }
3750 }
3751
3752 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
3753 {
3754         struct alc_spec *spec = codec->spec;
3755         alc_shutup(codec);
3756         if (spec && spec->power_hook)
3757                 spec->power_hook(codec);
3758         return 0;
3759 }
3760 #endif
3761
3762 #ifdef SND_HDA_NEEDS_RESUME
3763 static int alc_resume(struct hda_codec *codec)
3764 {
3765         codec->patch_ops.init(codec);
3766         snd_hda_codec_resume_amp(codec);
3767         snd_hda_codec_resume_cache(codec);
3768         return 0;
3769 }
3770 #endif
3771
3772 /*
3773  */
3774 static struct hda_codec_ops alc_patch_ops = {
3775         .build_controls = alc_build_controls,
3776         .build_pcms = alc_build_pcms,
3777         .init = alc_init,
3778         .free = alc_free,
3779         .unsol_event = alc_unsol_event,
3780 #ifdef SND_HDA_NEEDS_RESUME
3781         .resume = alc_resume,
3782 #endif
3783 #ifdef CONFIG_SND_HDA_POWER_SAVE
3784         .suspend = alc_suspend,
3785         .check_power_status = alc_check_power_status,
3786 #endif
3787         .reboot_notify = alc_shutup,
3788 };
3789
3790
3791 /*
3792  * Test configuration for debugging
3793  *
3794  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3795  * enum controls.
3796  */
3797 #ifdef CONFIG_SND_DEBUG
3798 static hda_nid_t alc880_test_dac_nids[4] = {
3799         0x02, 0x03, 0x04, 0x05
3800 };
3801
3802 static struct hda_input_mux alc880_test_capture_source = {
3803         .num_items = 7,
3804         .items = {
3805                 { "In-1", 0x0 },
3806                 { "In-2", 0x1 },
3807                 { "In-3", 0x2 },
3808                 { "In-4", 0x3 },
3809                 { "CD", 0x4 },
3810                 { "Front", 0x5 },
3811                 { "Surround", 0x6 },
3812         },
3813 };
3814
3815 static struct hda_channel_mode alc880_test_modes[4] = {
3816         { 2, NULL },
3817         { 4, NULL },
3818         { 6, NULL },
3819         { 8, NULL },
3820 };
3821
3822 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3823                                  struct snd_ctl_elem_info *uinfo)
3824 {
3825         static char *texts[] = {
3826                 "N/A", "Line Out", "HP Out",
3827                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3828         };
3829         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3830         uinfo->count = 1;
3831         uinfo->value.enumerated.items = 8;
3832         if (uinfo->value.enumerated.item >= 8)
3833                 uinfo->value.enumerated.item = 7;
3834         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3835         return 0;
3836 }
3837
3838 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3839                                 struct snd_ctl_elem_value *ucontrol)
3840 {
3841         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3842         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3843         unsigned int pin_ctl, item = 0;
3844
3845         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3846                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3847         if (pin_ctl & AC_PINCTL_OUT_EN) {
3848                 if (pin_ctl & AC_PINCTL_HP_EN)
3849                         item = 2;
3850                 else
3851                         item = 1;
3852         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3853                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3854                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3855                 case AC_PINCTL_VREF_50:  item = 4; break;
3856                 case AC_PINCTL_VREF_GRD: item = 5; break;
3857                 case AC_PINCTL_VREF_80:  item = 6; break;
3858                 case AC_PINCTL_VREF_100: item = 7; break;
3859                 }
3860         }
3861         ucontrol->value.enumerated.item[0] = item;
3862         return 0;
3863 }
3864
3865 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3866                                 struct snd_ctl_elem_value *ucontrol)
3867 {
3868         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3869         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3870         static unsigned int ctls[] = {
3871                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3872                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3873                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3874                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3875                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3876                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3877         };
3878         unsigned int old_ctl, new_ctl;
3879
3880         old_ctl = snd_hda_codec_read(codec, nid, 0,
3881                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3882         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3883         if (old_ctl != new_ctl) {
3884                 int val;
3885                 snd_hda_codec_write_cache(codec, nid, 0,
3886                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3887                                           new_ctl);
3888                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3889                         HDA_AMP_MUTE : 0;
3890                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3891                                          HDA_AMP_MUTE, val);
3892                 return 1;
3893         }
3894         return 0;
3895 }
3896
3897 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3898                                  struct snd_ctl_elem_info *uinfo)
3899 {
3900         static char *texts[] = {
3901                 "Front", "Surround", "CLFE", "Side"
3902         };
3903         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3904         uinfo->count = 1;
3905         uinfo->value.enumerated.items = 4;
3906         if (uinfo->value.enumerated.item >= 4)
3907                 uinfo->value.enumerated.item = 3;
3908         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3909         return 0;
3910 }
3911
3912 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3913                                 struct snd_ctl_elem_value *ucontrol)
3914 {
3915         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3916         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3917         unsigned int sel;
3918
3919         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3920         ucontrol->value.enumerated.item[0] = sel & 3;
3921         return 0;
3922 }
3923
3924 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3925                                 struct snd_ctl_elem_value *ucontrol)
3926 {
3927         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3928         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3929         unsigned int sel;
3930
3931         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3932         if (ucontrol->value.enumerated.item[0] != sel) {
3933                 sel = ucontrol->value.enumerated.item[0] & 3;
3934                 snd_hda_codec_write_cache(codec, nid, 0,
3935                                           AC_VERB_SET_CONNECT_SEL, sel);
3936                 return 1;
3937         }
3938         return 0;
3939 }
3940
3941 #define PIN_CTL_TEST(xname,nid) {                       \
3942                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3943                         .name = xname,                 \
3944                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
3945                         .info = alc_test_pin_ctl_info, \
3946                         .get = alc_test_pin_ctl_get,   \
3947                         .put = alc_test_pin_ctl_put,   \
3948                         .private_value = nid           \
3949                         }
3950
3951 #define PIN_SRC_TEST(xname,nid) {                       \
3952                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3953                         .name = xname,                 \
3954                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
3955                         .info = alc_test_pin_src_info, \
3956                         .get = alc_test_pin_src_get,   \
3957                         .put = alc_test_pin_src_put,   \
3958                         .private_value = nid           \
3959                         }
3960
3961 static struct snd_kcontrol_new alc880_test_mixer[] = {
3962         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3963         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3964         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3965         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3966         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3967         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3968         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3969         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3970         PIN_CTL_TEST("Front Pin Mode", 0x14),
3971         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3972         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3973         PIN_CTL_TEST("Side Pin Mode", 0x17),
3974         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3975         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3976         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3977         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3978         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3979         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3980         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3981         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3982         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3983         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3984         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3985         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3986         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3987         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3988         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3989         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3990         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3991         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3992         {
3993                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3994                 .name = "Channel Mode",
3995                 .info = alc_ch_mode_info,
3996                 .get = alc_ch_mode_get,
3997                 .put = alc_ch_mode_put,
3998         },
3999         { } /* end */
4000 };
4001
4002 static struct hda_verb alc880_test_init_verbs[] = {
4003         /* Unmute inputs of 0x0c - 0x0f */
4004         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4005         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4006         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4007         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4008         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4009         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4010         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4011         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4012         /* Vol output for 0x0c-0x0f */
4013         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4014         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4015         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4016         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4017         /* Set output pins 0x14-0x17 */
4018         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4019         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4020         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4021         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4022         /* Unmute output pins 0x14-0x17 */
4023         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4024         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4025         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4026         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4027         /* Set input pins 0x18-0x1c */
4028         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4029         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4030         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4031         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4032         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4033         /* Mute input pins 0x18-0x1b */
4034         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4035         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4036         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4037         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4038         /* ADC set up */
4039         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4040         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4041         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4042         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4043         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4044         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4045         /* Analog input/passthru */
4046         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4047         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4048         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4049         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4050         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4051         { }
4052 };
4053 #endif
4054
4055 /*
4056  */
4057
4058 static const char *alc880_models[ALC880_MODEL_LAST] = {
4059         [ALC880_3ST]            = "3stack",
4060         [ALC880_TCL_S700]       = "tcl",
4061         [ALC880_3ST_DIG]        = "3stack-digout",
4062         [ALC880_CLEVO]          = "clevo",
4063         [ALC880_5ST]            = "5stack",
4064         [ALC880_5ST_DIG]        = "5stack-digout",
4065         [ALC880_W810]           = "w810",
4066         [ALC880_Z71V]           = "z71v",
4067         [ALC880_6ST]            = "6stack",
4068         [ALC880_6ST_DIG]        = "6stack-digout",
4069         [ALC880_ASUS]           = "asus",
4070         [ALC880_ASUS_W1V]       = "asus-w1v",
4071         [ALC880_ASUS_DIG]       = "asus-dig",
4072         [ALC880_ASUS_DIG2]      = "asus-dig2",
4073         [ALC880_UNIWILL_DIG]    = "uniwill",
4074         [ALC880_UNIWILL_P53]    = "uniwill-p53",
4075         [ALC880_FUJITSU]        = "fujitsu",
4076         [ALC880_F1734]          = "F1734",
4077         [ALC880_LG]             = "lg",
4078         [ALC880_LG_LW]          = "lg-lw",
4079         [ALC880_MEDION_RIM]     = "medion",
4080 #ifdef CONFIG_SND_DEBUG
4081         [ALC880_TEST]           = "test",
4082 #endif
4083         [ALC880_AUTO]           = "auto",
4084 };
4085
4086 static struct snd_pci_quirk alc880_cfg_tbl[] = {
4087         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4088         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4089         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4090         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4091         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4092         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4093         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4094         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4095         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4096         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4097         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4098         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4099         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4100         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4101         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4102         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4103         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4104         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4105         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4106         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4107         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4108         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4109         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4110         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4111         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4112         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4113         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4114         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4115         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4116         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4117         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4118         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4119         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4120         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4121         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4122         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4123         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4124         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4125         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4126         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4127         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4128         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4129         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4130         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4131         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4132         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4133         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4134         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4135         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4136         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
4137         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4138         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4139         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4140         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4141         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4142         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4143         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4144         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4145         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4146         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4147         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4148         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4149         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4150         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4151         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4152         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4153         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4154         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4155         /* default Intel */
4156         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4157         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4158         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4159         {}
4160 };
4161
4162 /*
4163  * ALC880 codec presets
4164  */
4165 static struct alc_config_preset alc880_presets[] = {
4166         [ALC880_3ST] = {
4167                 .mixers = { alc880_three_stack_mixer },
4168                 .init_verbs = { alc880_volume_init_verbs,
4169                                 alc880_pin_3stack_init_verbs },
4170                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4171                 .dac_nids = alc880_dac_nids,
4172                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4173                 .channel_mode = alc880_threestack_modes,
4174                 .need_dac_fix = 1,
4175                 .input_mux = &alc880_capture_source,
4176         },
4177         [ALC880_3ST_DIG] = {
4178                 .mixers = { alc880_three_stack_mixer },
4179                 .init_verbs = { alc880_volume_init_verbs,
4180                                 alc880_pin_3stack_init_verbs },
4181                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4182                 .dac_nids = alc880_dac_nids,
4183                 .dig_out_nid = ALC880_DIGOUT_NID,
4184                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4185                 .channel_mode = alc880_threestack_modes,
4186                 .need_dac_fix = 1,
4187                 .input_mux = &alc880_capture_source,
4188         },
4189         [ALC880_TCL_S700] = {
4190                 .mixers = { alc880_tcl_s700_mixer },
4191                 .init_verbs = { alc880_volume_init_verbs,
4192                                 alc880_pin_tcl_S700_init_verbs,
4193                                 alc880_gpio2_init_verbs },
4194                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4195                 .dac_nids = alc880_dac_nids,
4196                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4197                 .num_adc_nids = 1, /* single ADC */
4198                 .hp_nid = 0x03,
4199                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4200                 .channel_mode = alc880_2_jack_modes,
4201                 .input_mux = &alc880_capture_source,
4202         },
4203         [ALC880_5ST] = {
4204                 .mixers = { alc880_three_stack_mixer,
4205                             alc880_five_stack_mixer},
4206                 .init_verbs = { alc880_volume_init_verbs,
4207                                 alc880_pin_5stack_init_verbs },
4208                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4209                 .dac_nids = alc880_dac_nids,
4210                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4211                 .channel_mode = alc880_fivestack_modes,
4212                 .input_mux = &alc880_capture_source,
4213         },
4214         [ALC880_5ST_DIG] = {
4215                 .mixers = { alc880_three_stack_mixer,
4216                             alc880_five_stack_mixer },
4217                 .init_verbs = { alc880_volume_init_verbs,
4218                                 alc880_pin_5stack_init_verbs },
4219                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4220                 .dac_nids = alc880_dac_nids,
4221                 .dig_out_nid = ALC880_DIGOUT_NID,
4222                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4223                 .channel_mode = alc880_fivestack_modes,
4224                 .input_mux = &alc880_capture_source,
4225         },
4226         [ALC880_6ST] = {
4227                 .mixers = { alc880_six_stack_mixer },
4228                 .init_verbs = { alc880_volume_init_verbs,
4229                                 alc880_pin_6stack_init_verbs },
4230                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4231                 .dac_nids = alc880_6st_dac_nids,
4232                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4233                 .channel_mode = alc880_sixstack_modes,
4234                 .input_mux = &alc880_6stack_capture_source,
4235         },
4236         [ALC880_6ST_DIG] = {
4237                 .mixers = { alc880_six_stack_mixer },
4238                 .init_verbs = { alc880_volume_init_verbs,
4239                                 alc880_pin_6stack_init_verbs },
4240                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4241                 .dac_nids = alc880_6st_dac_nids,
4242                 .dig_out_nid = ALC880_DIGOUT_NID,
4243                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4244                 .channel_mode = alc880_sixstack_modes,
4245                 .input_mux = &alc880_6stack_capture_source,
4246         },
4247         [ALC880_W810] = {
4248                 .mixers = { alc880_w810_base_mixer },
4249                 .init_verbs = { alc880_volume_init_verbs,
4250                                 alc880_pin_w810_init_verbs,
4251                                 alc880_gpio2_init_verbs },
4252                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4253                 .dac_nids = alc880_w810_dac_nids,
4254                 .dig_out_nid = ALC880_DIGOUT_NID,
4255                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4256                 .channel_mode = alc880_w810_modes,
4257                 .input_mux = &alc880_capture_source,
4258         },
4259         [ALC880_Z71V] = {
4260                 .mixers = { alc880_z71v_mixer },
4261                 .init_verbs = { alc880_volume_init_verbs,
4262                                 alc880_pin_z71v_init_verbs },
4263                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4264                 .dac_nids = alc880_z71v_dac_nids,
4265                 .dig_out_nid = ALC880_DIGOUT_NID,
4266                 .hp_nid = 0x03,
4267                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4268                 .channel_mode = alc880_2_jack_modes,
4269                 .input_mux = &alc880_capture_source,
4270         },
4271         [ALC880_F1734] = {
4272                 .mixers = { alc880_f1734_mixer },
4273                 .init_verbs = { alc880_volume_init_verbs,
4274                                 alc880_pin_f1734_init_verbs },
4275                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4276                 .dac_nids = alc880_f1734_dac_nids,
4277                 .hp_nid = 0x02,
4278                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4279                 .channel_mode = alc880_2_jack_modes,
4280                 .input_mux = &alc880_f1734_capture_source,
4281                 .unsol_event = alc880_uniwill_p53_unsol_event,
4282                 .setup = alc880_uniwill_p53_setup,
4283                 .init_hook = alc_automute_amp,
4284         },
4285         [ALC880_ASUS] = {
4286                 .mixers = { alc880_asus_mixer },
4287                 .init_verbs = { alc880_volume_init_verbs,
4288                                 alc880_pin_asus_init_verbs,
4289                                 alc880_gpio1_init_verbs },
4290                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4291                 .dac_nids = alc880_asus_dac_nids,
4292                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4293                 .channel_mode = alc880_asus_modes,
4294                 .need_dac_fix = 1,
4295                 .input_mux = &alc880_capture_source,
4296         },
4297         [ALC880_ASUS_DIG] = {
4298                 .mixers = { alc880_asus_mixer },
4299                 .init_verbs = { alc880_volume_init_verbs,
4300                                 alc880_pin_asus_init_verbs,
4301                                 alc880_gpio1_init_verbs },
4302                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4303                 .dac_nids = alc880_asus_dac_nids,
4304                 .dig_out_nid = ALC880_DIGOUT_NID,
4305                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4306                 .channel_mode = alc880_asus_modes,
4307                 .need_dac_fix = 1,
4308                 .input_mux = &alc880_capture_source,
4309         },
4310         [ALC880_ASUS_DIG2] = {
4311                 .mixers = { alc880_asus_mixer },
4312                 .init_verbs = { alc880_volume_init_verbs,
4313                                 alc880_pin_asus_init_verbs,
4314                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4315                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4316                 .dac_nids = alc880_asus_dac_nids,
4317                 .dig_out_nid = ALC880_DIGOUT_NID,
4318                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4319                 .channel_mode = alc880_asus_modes,
4320                 .need_dac_fix = 1,
4321                 .input_mux = &alc880_capture_source,
4322         },
4323         [ALC880_ASUS_W1V] = {
4324                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4325                 .init_verbs = { alc880_volume_init_verbs,
4326                                 alc880_pin_asus_init_verbs,
4327                                 alc880_gpio1_init_verbs },
4328                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4329                 .dac_nids = alc880_asus_dac_nids,
4330                 .dig_out_nid = ALC880_DIGOUT_NID,
4331                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4332                 .channel_mode = alc880_asus_modes,
4333                 .need_dac_fix = 1,
4334                 .input_mux = &alc880_capture_source,
4335         },
4336         [ALC880_UNIWILL_DIG] = {
4337                 .mixers = { alc880_asus_mixer },
4338                 .init_verbs = { alc880_volume_init_verbs,
4339                                 alc880_pin_asus_init_verbs },
4340                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4341                 .dac_nids = alc880_asus_dac_nids,
4342                 .dig_out_nid = ALC880_DIGOUT_NID,
4343                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4344                 .channel_mode = alc880_asus_modes,
4345                 .need_dac_fix = 1,
4346                 .input_mux = &alc880_capture_source,
4347         },
4348         [ALC880_UNIWILL] = {
4349                 .mixers = { alc880_uniwill_mixer },
4350                 .init_verbs = { alc880_volume_init_verbs,
4351                                 alc880_uniwill_init_verbs },
4352                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4353                 .dac_nids = alc880_asus_dac_nids,
4354                 .dig_out_nid = ALC880_DIGOUT_NID,
4355                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4356                 .channel_mode = alc880_threestack_modes,
4357                 .need_dac_fix = 1,
4358                 .input_mux = &alc880_capture_source,
4359                 .unsol_event = alc880_uniwill_unsol_event,
4360                 .setup = alc880_uniwill_setup,
4361                 .init_hook = alc880_uniwill_init_hook,
4362         },
4363         [ALC880_UNIWILL_P53] = {
4364                 .mixers = { alc880_uniwill_p53_mixer },
4365                 .init_verbs = { alc880_volume_init_verbs,
4366                                 alc880_uniwill_p53_init_verbs },
4367                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4368                 .dac_nids = alc880_asus_dac_nids,
4369                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4370                 .channel_mode = alc880_threestack_modes,
4371                 .input_mux = &alc880_capture_source,
4372                 .unsol_event = alc880_uniwill_p53_unsol_event,
4373                 .setup = alc880_uniwill_p53_setup,
4374                 .init_hook = alc_automute_amp,
4375         },
4376         [ALC880_FUJITSU] = {
4377                 .mixers = { alc880_fujitsu_mixer },
4378                 .init_verbs = { alc880_volume_init_verbs,
4379                                 alc880_uniwill_p53_init_verbs,
4380                                 alc880_beep_init_verbs },
4381                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4382                 .dac_nids = alc880_dac_nids,
4383                 .dig_out_nid = ALC880_DIGOUT_NID,
4384                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4385                 .channel_mode = alc880_2_jack_modes,
4386                 .input_mux = &alc880_capture_source,
4387                 .unsol_event = alc880_uniwill_p53_unsol_event,
4388                 .setup = alc880_uniwill_p53_setup,
4389                 .init_hook = alc_automute_amp,
4390         },
4391         [ALC880_CLEVO] = {
4392                 .mixers = { alc880_three_stack_mixer },
4393                 .init_verbs = { alc880_volume_init_verbs,
4394                                 alc880_pin_clevo_init_verbs },
4395                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4396                 .dac_nids = alc880_dac_nids,
4397                 .hp_nid = 0x03,
4398                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4399                 .channel_mode = alc880_threestack_modes,
4400                 .need_dac_fix = 1,
4401                 .input_mux = &alc880_capture_source,
4402         },
4403         [ALC880_LG] = {
4404                 .mixers = { alc880_lg_mixer },
4405                 .init_verbs = { alc880_volume_init_verbs,
4406                                 alc880_lg_init_verbs },
4407                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4408                 .dac_nids = alc880_lg_dac_nids,
4409                 .dig_out_nid = ALC880_DIGOUT_NID,
4410                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4411                 .channel_mode = alc880_lg_ch_modes,
4412                 .need_dac_fix = 1,
4413                 .input_mux = &alc880_lg_capture_source,
4414                 .unsol_event = alc_automute_amp_unsol_event,
4415                 .setup = alc880_lg_setup,
4416                 .init_hook = alc_automute_amp,
4417 #ifdef CONFIG_SND_HDA_POWER_SAVE
4418                 .loopbacks = alc880_lg_loopbacks,
4419 #endif
4420         },
4421         [ALC880_LG_LW] = {
4422                 .mixers = { alc880_lg_lw_mixer },
4423                 .init_verbs = { alc880_volume_init_verbs,
4424                                 alc880_lg_lw_init_verbs },
4425                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4426                 .dac_nids = alc880_dac_nids,
4427                 .dig_out_nid = ALC880_DIGOUT_NID,
4428                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4429                 .channel_mode = alc880_lg_lw_modes,
4430                 .input_mux = &alc880_lg_lw_capture_source,
4431                 .unsol_event = alc_automute_amp_unsol_event,
4432                 .setup = alc880_lg_lw_setup,
4433                 .init_hook = alc_automute_amp,
4434         },
4435         [ALC880_MEDION_RIM] = {
4436                 .mixers = { alc880_medion_rim_mixer },
4437                 .init_verbs = { alc880_volume_init_verbs,
4438                                 alc880_medion_rim_init_verbs,
4439                                 alc_gpio2_init_verbs },
4440                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4441                 .dac_nids = alc880_dac_nids,
4442                 .dig_out_nid = ALC880_DIGOUT_NID,
4443                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4444                 .channel_mode = alc880_2_jack_modes,
4445                 .input_mux = &alc880_medion_rim_capture_source,
4446                 .unsol_event = alc880_medion_rim_unsol_event,
4447                 .setup = alc880_medion_rim_setup,
4448                 .init_hook = alc880_medion_rim_automute,
4449         },
4450 #ifdef CONFIG_SND_DEBUG
4451         [ALC880_TEST] = {
4452                 .mixers = { alc880_test_mixer },
4453                 .init_verbs = { alc880_test_init_verbs },
4454                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4455                 .dac_nids = alc880_test_dac_nids,
4456                 .dig_out_nid = ALC880_DIGOUT_NID,
4457                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4458                 .channel_mode = alc880_test_modes,
4459                 .input_mux = &alc880_test_capture_source,
4460         },
4461 #endif
4462 };
4463
4464 /*
4465  * Automatic parse of I/O pins from the BIOS configuration
4466  */
4467
4468 enum {
4469         ALC_CTL_WIDGET_VOL,
4470         ALC_CTL_WIDGET_MUTE,
4471         ALC_CTL_BIND_MUTE,
4472 };
4473 static struct snd_kcontrol_new alc880_control_templates[] = {
4474         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4475         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4476         HDA_BIND_MUTE(NULL, 0, 0, 0),
4477 };
4478
4479 /* add dynamic controls */
4480 static int add_control(struct alc_spec *spec, int type, const char *name,
4481                        unsigned long val)
4482 {
4483         struct snd_kcontrol_new *knew;
4484
4485         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4486         knew = snd_array_new(&spec->kctls);
4487         if (!knew)
4488                 return -ENOMEM;
4489         *knew = alc880_control_templates[type];
4490         knew->name = kstrdup(name, GFP_KERNEL);
4491         if (!knew->name)
4492                 return -ENOMEM;
4493         if (get_amp_nid_(val))
4494                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
4495         knew->private_value = val;
4496         return 0;
4497 }
4498
4499 static int add_control_with_pfx(struct alc_spec *spec, int type,
4500                                 const char *pfx, const char *dir,
4501                                 const char *sfx, unsigned long val)
4502 {
4503         char name[32];
4504         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
4505         return add_control(spec, type, name, val);
4506 }
4507
4508 #define add_pb_vol_ctrl(spec, type, pfx, val) \
4509         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", val)
4510 #define add_pb_sw_ctrl(spec, type, pfx, val) \
4511         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", val)
4512
4513 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4514 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4515 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4516 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4517 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4518 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4519 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4520 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4521 #define ALC880_PIN_CD_NID               0x1c
4522
4523 /* fill in the dac_nids table from the parsed pin configuration */
4524 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4525                                      const struct auto_pin_cfg *cfg)
4526 {
4527         hda_nid_t nid;
4528         int assigned[4];
4529         int i, j;
4530
4531         memset(assigned, 0, sizeof(assigned));
4532         spec->multiout.dac_nids = spec->private_dac_nids;
4533
4534         /* check the pins hardwired to audio widget */
4535         for (i = 0; i < cfg->line_outs; i++) {
4536                 nid = cfg->line_out_pins[i];
4537                 if (alc880_is_fixed_pin(nid)) {
4538                         int idx = alc880_fixed_pin_idx(nid);
4539                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4540                         assigned[idx] = 1;
4541                 }
4542         }
4543         /* left pins can be connect to any audio widget */
4544         for (i = 0; i < cfg->line_outs; i++) {
4545                 nid = cfg->line_out_pins[i];
4546                 if (alc880_is_fixed_pin(nid))
4547                         continue;
4548                 /* search for an empty channel */
4549                 for (j = 0; j < cfg->line_outs; j++) {
4550                         if (!assigned[j]) {
4551                                 spec->multiout.dac_nids[i] =
4552                                         alc880_idx_to_dac(j);
4553                                 assigned[j] = 1;
4554                                 break;
4555                         }
4556                 }
4557         }
4558         spec->multiout.num_dacs = cfg->line_outs;
4559         return 0;
4560 }
4561
4562 /* add playback controls from the parsed DAC table */
4563 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4564                                              const struct auto_pin_cfg *cfg)
4565 {
4566         static const char *chname[4] = {
4567                 "Front", "Surround", NULL /*CLFE*/, "Side"
4568         };
4569         hda_nid_t nid;
4570         int i, err;
4571
4572         for (i = 0; i < cfg->line_outs; i++) {
4573                 if (!spec->multiout.dac_nids[i])
4574                         continue;
4575                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4576                 if (i == 2) {
4577                         /* Center/LFE */
4578                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4579                                               "Center",
4580                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4581                                                               HDA_OUTPUT));
4582                         if (err < 0)
4583                                 return err;
4584                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4585                                               "LFE",
4586                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4587                                                               HDA_OUTPUT));
4588                         if (err < 0)
4589                                 return err;
4590                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4591                                              "Center",
4592                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4593                                                               HDA_INPUT));
4594                         if (err < 0)
4595                                 return err;
4596                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4597                                              "LFE",
4598                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4599                                                               HDA_INPUT));
4600                         if (err < 0)
4601                                 return err;
4602                 } else {
4603                         const char *pfx;
4604                         if (cfg->line_outs == 1 &&
4605                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
4606                                 pfx = "Speaker";
4607                         else
4608                                 pfx = chname[i];
4609                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4610                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4611                                                               HDA_OUTPUT));
4612                         if (err < 0)
4613                                 return err;
4614                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4615                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4616                                                               HDA_INPUT));
4617                         if (err < 0)
4618                                 return err;
4619                 }
4620         }
4621         return 0;
4622 }
4623
4624 /* add playback controls for speaker and HP outputs */
4625 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4626                                         const char *pfx)
4627 {
4628         hda_nid_t nid;
4629         int err;
4630
4631         if (!pin)
4632                 return 0;
4633
4634         if (alc880_is_fixed_pin(pin)) {
4635                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4636                 /* specify the DAC as the extra output */
4637                 if (!spec->multiout.hp_nid)
4638                         spec->multiout.hp_nid = nid;
4639                 else
4640                         spec->multiout.extra_out_nid[0] = nid;
4641                 /* control HP volume/switch on the output mixer amp */
4642                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4643                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4644                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4645                 if (err < 0)
4646                         return err;
4647                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4648                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4649                 if (err < 0)
4650                         return err;
4651         } else if (alc880_is_multi_pin(pin)) {
4652                 /* set manual connection */
4653                 /* we have only a switch on HP-out PIN */
4654                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
4655                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4656                 if (err < 0)
4657                         return err;
4658         }
4659         return 0;
4660 }
4661
4662 /* create input playback/capture controls for the given pin */
4663 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4664                             const char *ctlname,
4665                             int idx, hda_nid_t mix_nid)
4666 {
4667         int err;
4668
4669         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
4670                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4671         if (err < 0)
4672                 return err;
4673         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
4674                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4675         if (err < 0)
4676                 return err;
4677         return 0;
4678 }
4679
4680 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
4681 {
4682         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
4683         return (pincap & AC_PINCAP_IN) != 0;
4684 }
4685
4686 /* create playback/capture controls for input pins */
4687 static int alc_auto_create_input_ctls(struct hda_codec *codec,
4688                                       const struct auto_pin_cfg *cfg,
4689                                       hda_nid_t mixer,
4690                                       hda_nid_t cap1, hda_nid_t cap2)
4691 {
4692         struct alc_spec *spec = codec->spec;
4693         struct hda_input_mux *imux = &spec->private_imux[0];
4694         int i, err, idx;
4695
4696         for (i = 0; i < AUTO_PIN_LAST; i++) {
4697                 hda_nid_t pin;
4698
4699                 pin = cfg->input_pins[i];
4700                 if (!alc_is_input_pin(codec, pin))
4701                         continue;
4702
4703                 if (mixer) {
4704                         idx = get_connection_index(codec, mixer, pin);
4705                         if (idx >= 0) {
4706                                 err = new_analog_input(spec, pin,
4707                                                        auto_pin_cfg_labels[i],
4708                                                        idx, mixer);
4709                                 if (err < 0)
4710                                         return err;
4711                         }
4712                 }
4713
4714                 if (!cap1)
4715                         continue;
4716                 idx = get_connection_index(codec, cap1, pin);
4717                 if (idx < 0 && cap2)
4718                         idx = get_connection_index(codec, cap2, pin);
4719                 if (idx >= 0) {
4720                         imux->items[imux->num_items].label =
4721                                 auto_pin_cfg_labels[i];
4722                         imux->items[imux->num_items].index = idx;
4723                         imux->num_items++;
4724                 }
4725         }
4726         return 0;
4727 }
4728
4729 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
4730                                                 const struct auto_pin_cfg *cfg)
4731 {
4732         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
4733 }
4734
4735 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4736                                unsigned int pin_type)
4737 {
4738         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4739                             pin_type);
4740         /* unmute pin */
4741         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4742                             AMP_OUT_UNMUTE);
4743 }
4744
4745 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4746                                               hda_nid_t nid, int pin_type,
4747                                               int dac_idx)
4748 {
4749         alc_set_pin_output(codec, nid, pin_type);
4750         /* need the manual connection? */
4751         if (alc880_is_multi_pin(nid)) {
4752                 struct alc_spec *spec = codec->spec;
4753                 int idx = alc880_multi_pin_idx(nid);
4754                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4755                                     AC_VERB_SET_CONNECT_SEL,
4756                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4757         }
4758 }
4759
4760 static int get_pin_type(int line_out_type)
4761 {
4762         if (line_out_type == AUTO_PIN_HP_OUT)
4763                 return PIN_HP;
4764         else
4765                 return PIN_OUT;
4766 }
4767
4768 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4769 {
4770         struct alc_spec *spec = codec->spec;
4771         int i;
4772
4773         for (i = 0; i < spec->autocfg.line_outs; i++) {
4774                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4775                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4776                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4777         }
4778 }
4779
4780 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4781 {
4782         struct alc_spec *spec = codec->spec;
4783         hda_nid_t pin;
4784
4785         pin = spec->autocfg.speaker_pins[0];
4786         if (pin) /* connect to front */
4787                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4788         pin = spec->autocfg.hp_pins[0];
4789         if (pin) /* connect to front */
4790                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4791 }
4792
4793 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4794 {
4795         struct alc_spec *spec = codec->spec;
4796         int i;
4797
4798         for (i = 0; i < AUTO_PIN_LAST; i++) {
4799                 hda_nid_t nid = spec->autocfg.input_pins[i];
4800                 if (alc_is_input_pin(codec, nid)) {
4801                         alc_set_input_pin(codec, nid, i);
4802                         if (nid != ALC880_PIN_CD_NID &&
4803                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4804                                 snd_hda_codec_write(codec, nid, 0,
4805                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4806                                                     AMP_OUT_MUTE);
4807                 }
4808         }
4809 }
4810
4811 /* parse the BIOS configuration and set up the alc_spec */
4812 /* return 1 if successful, 0 if the proper config is not found,
4813  * or a negative error code
4814  */
4815 static int alc880_parse_auto_config(struct hda_codec *codec)
4816 {
4817         struct alc_spec *spec = codec->spec;
4818         int i, err;
4819         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4820
4821         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4822                                            alc880_ignore);
4823         if (err < 0)
4824                 return err;
4825         if (!spec->autocfg.line_outs)
4826                 return 0; /* can't find valid BIOS pin config */
4827
4828         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4829         if (err < 0)
4830                 return err;
4831         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4832         if (err < 0)
4833                 return err;
4834         err = alc880_auto_create_extra_out(spec,
4835                                            spec->autocfg.speaker_pins[0],
4836                                            "Speaker");
4837         if (err < 0)
4838                 return err;
4839         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4840                                            "Headphone");
4841         if (err < 0)
4842                 return err;
4843         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
4844         if (err < 0)
4845                 return err;
4846
4847         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4848
4849         /* check multiple SPDIF-out (for recent codecs) */
4850         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4851                 hda_nid_t dig_nid;
4852                 err = snd_hda_get_connections(codec,
4853                                               spec->autocfg.dig_out_pins[i],
4854                                               &dig_nid, 1);
4855                 if (err < 0)
4856                         continue;
4857                 if (!i)
4858                         spec->multiout.dig_out_nid = dig_nid;
4859                 else {
4860                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4861                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
4862                                 break;
4863                         spec->slave_dig_outs[i - 1] = dig_nid;
4864                 }
4865         }
4866         if (spec->autocfg.dig_in_pin)
4867                 spec->dig_in_nid = ALC880_DIGIN_NID;
4868
4869         if (spec->kctls.list)
4870                 add_mixer(spec, spec->kctls.list);
4871
4872         add_verb(spec, alc880_volume_init_verbs);
4873
4874         spec->num_mux_defs = 1;
4875         spec->input_mux = &spec->private_imux[0];
4876
4877         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
4878
4879         return 1;
4880 }
4881
4882 /* additional initialization for auto-configuration model */
4883 static void alc880_auto_init(struct hda_codec *codec)
4884 {
4885         struct alc_spec *spec = codec->spec;
4886         alc880_auto_init_multi_out(codec);
4887         alc880_auto_init_extra_out(codec);
4888         alc880_auto_init_analog_input(codec);
4889         if (spec->unsol_event)
4890                 alc_inithook(codec);
4891 }
4892
4893 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
4894  * one of two digital mic pins, e.g. on ALC272
4895  */
4896 static void fixup_automic_adc(struct hda_codec *codec)
4897 {
4898         struct alc_spec *spec = codec->spec;
4899         int i;
4900
4901         for (i = 0; i < spec->num_adc_nids; i++) {
4902                 hda_nid_t cap = spec->capsrc_nids ?
4903                         spec->capsrc_nids[i] : spec->adc_nids[i];
4904                 int iidx, eidx;
4905
4906                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
4907                 if (iidx < 0)
4908                         continue;
4909                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
4910                 if (eidx < 0)
4911                         continue;
4912                 spec->int_mic.mux_idx = iidx;
4913                 spec->ext_mic.mux_idx = eidx;
4914                 if (spec->capsrc_nids)
4915                         spec->capsrc_nids += i;
4916                 spec->adc_nids += i;
4917                 spec->num_adc_nids = 1;
4918                 return;
4919         }
4920         snd_printd(KERN_INFO "hda_codec: %s: "
4921                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
4922                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
4923         spec->auto_mic = 0; /* disable auto-mic to be sure */
4924 }
4925
4926 /* choose the ADC/MUX containing the input pin and initialize the setup */
4927 static void fixup_single_adc(struct hda_codec *codec)
4928 {
4929         struct alc_spec *spec = codec->spec;
4930         hda_nid_t pin = 0;
4931         int i;
4932
4933         /* search for the input pin; there must be only one */
4934         for (i = 0; i < AUTO_PIN_LAST; i++) {
4935                 if (spec->autocfg.input_pins[i]) {
4936                         pin = spec->autocfg.input_pins[i];
4937                         break;
4938                 }
4939         }
4940         if (!pin)
4941                 return;
4942
4943         /* set the default connection to that pin */
4944         for (i = 0; i < spec->num_adc_nids; i++) {
4945                 hda_nid_t cap = spec->capsrc_nids ?
4946                         spec->capsrc_nids[i] : spec->adc_nids[i];
4947                 int idx;
4948
4949                 idx = get_connection_index(codec, cap, pin);
4950                 if (idx < 0)
4951                         continue;
4952                 /* use only this ADC */
4953                 if (spec->capsrc_nids)
4954                         spec->capsrc_nids += i;
4955                 spec->adc_nids += i;
4956                 spec->num_adc_nids = 1;
4957                 /* select or unmute this route */
4958                 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
4959                         snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
4960                                                  HDA_AMP_MUTE, 0);
4961                 } else {
4962                         snd_hda_codec_write_cache(codec, cap, 0,
4963                                           AC_VERB_SET_CONNECT_SEL, idx);
4964                 }
4965                 return;
4966         }
4967 }
4968
4969 static void set_capture_mixer(struct hda_codec *codec)
4970 {
4971         struct alc_spec *spec = codec->spec;
4972         static struct snd_kcontrol_new *caps[2][3] = {
4973                 { alc_capture_mixer_nosrc1,
4974                   alc_capture_mixer_nosrc2,
4975                   alc_capture_mixer_nosrc3 },
4976                 { alc_capture_mixer1,
4977                   alc_capture_mixer2,
4978                   alc_capture_mixer3 },
4979         };
4980         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4981                 int mux = 0;
4982                 if (spec->auto_mic)
4983                         fixup_automic_adc(codec);
4984                 else if (spec->input_mux) {
4985                         if (spec->input_mux->num_items > 1)
4986                                 mux = 1;
4987                         else if (spec->input_mux->num_items == 1)
4988                                 fixup_single_adc(codec);
4989                 }
4990                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4991         }
4992 }
4993
4994 /* fill adc_nids (and capsrc_nids) containing all active input pins */
4995 static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
4996                                  int num_nids)
4997 {
4998         struct alc_spec *spec = codec->spec;
4999         int n;
5000         hda_nid_t fallback_adc = 0, fallback_cap = 0;
5001
5002         for (n = 0; n < num_nids; n++) {
5003                 hda_nid_t adc, cap;
5004                 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5005                 int nconns, i, j;
5006
5007                 adc = nids[n];
5008                 if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5009                         continue;
5010                 cap = adc;
5011                 nconns = snd_hda_get_connections(codec, cap, conn,
5012                                                  ARRAY_SIZE(conn));
5013                 if (nconns == 1) {
5014                         cap = conn[0];
5015                         nconns = snd_hda_get_connections(codec, cap, conn,
5016                                                          ARRAY_SIZE(conn));
5017                 }
5018                 if (nconns <= 0)
5019                         continue;
5020                 if (!fallback_adc) {
5021                         fallback_adc = adc;
5022                         fallback_cap = cap;
5023                 }
5024                 for (i = 0; i < AUTO_PIN_LAST; i++) {
5025                         hda_nid_t nid = spec->autocfg.input_pins[i];
5026                         if (!nid)
5027                                 continue;
5028                         for (j = 0; j < nconns; j++) {
5029                                 if (conn[j] == nid)
5030                                         break;
5031                         }
5032                         if (j >= nconns)
5033                                 break;
5034                 }
5035                 if (i >= AUTO_PIN_LAST) {
5036                         int num_adcs = spec->num_adc_nids;
5037                         spec->private_adc_nids[num_adcs] = adc;
5038                         spec->private_capsrc_nids[num_adcs] = cap;
5039                         spec->num_adc_nids++;
5040                         spec->adc_nids = spec->private_adc_nids;
5041                         if (adc != cap)
5042                                 spec->capsrc_nids = spec->private_capsrc_nids;
5043                 }
5044         }
5045         if (!spec->num_adc_nids) {
5046                 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5047                        " using fallback 0x%x\n",
5048                        codec->chip_name, fallback_adc);
5049                 spec->private_adc_nids[0] = fallback_adc;
5050                 spec->adc_nids = spec->private_adc_nids;
5051                 if (fallback_adc != fallback_cap) {
5052                         spec->private_capsrc_nids[0] = fallback_cap;
5053                         spec->capsrc_nids = spec->private_adc_nids;
5054                 }
5055         }
5056 }
5057
5058 #ifdef CONFIG_SND_HDA_INPUT_BEEP
5059 #define set_beep_amp(spec, nid, idx, dir) \
5060         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5061 #else
5062 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
5063 #endif
5064
5065 /*
5066  * OK, here we have finally the patch for ALC880
5067  */
5068
5069 static int patch_alc880(struct hda_codec *codec)
5070 {
5071         struct alc_spec *spec;
5072         int board_config;
5073         int err;
5074
5075         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5076         if (spec == NULL)
5077                 return -ENOMEM;
5078
5079         codec->spec = spec;
5080
5081         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5082                                                   alc880_models,
5083                                                   alc880_cfg_tbl);
5084         if (board_config < 0) {
5085                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5086                        codec->chip_name);
5087                 board_config = ALC880_AUTO;
5088         }
5089
5090         if (board_config == ALC880_AUTO) {
5091                 /* automatic parse from the BIOS config */
5092                 err = alc880_parse_auto_config(codec);
5093                 if (err < 0) {
5094                         alc_free(codec);
5095                         return err;
5096                 } else if (!err) {
5097                         printk(KERN_INFO
5098                                "hda_codec: Cannot set up configuration "
5099                                "from BIOS.  Using 3-stack mode...\n");
5100                         board_config = ALC880_3ST;
5101                 }
5102         }
5103
5104         err = snd_hda_attach_beep_device(codec, 0x1);
5105         if (err < 0) {
5106                 alc_free(codec);
5107                 return err;
5108         }
5109
5110         if (board_config != ALC880_AUTO)
5111                 setup_preset(codec, &alc880_presets[board_config]);
5112
5113         spec->stream_analog_playback = &alc880_pcm_analog_playback;
5114         spec->stream_analog_capture = &alc880_pcm_analog_capture;
5115         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
5116
5117         spec->stream_digital_playback = &alc880_pcm_digital_playback;
5118         spec->stream_digital_capture = &alc880_pcm_digital_capture;
5119
5120         if (!spec->adc_nids && spec->input_mux) {
5121                 /* check whether NID 0x07 is valid */
5122                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
5123                 /* get type */
5124                 wcap = get_wcaps_type(wcap);
5125                 if (wcap != AC_WID_AUD_IN) {
5126                         spec->adc_nids = alc880_adc_nids_alt;
5127                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
5128                 } else {
5129                         spec->adc_nids = alc880_adc_nids;
5130                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
5131                 }
5132         }
5133         set_capture_mixer(codec);
5134         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5135
5136         spec->vmaster_nid = 0x0c;
5137
5138         codec->patch_ops = alc_patch_ops;
5139         if (board_config == ALC880_AUTO)
5140                 spec->init_hook = alc880_auto_init;
5141 #ifdef CONFIG_SND_HDA_POWER_SAVE
5142         if (!spec->loopback.amplist)
5143                 spec->loopback.amplist = alc880_loopbacks;
5144 #endif
5145
5146         return 0;
5147 }
5148
5149
5150 /*
5151  * ALC260 support
5152  */
5153
5154 static hda_nid_t alc260_dac_nids[1] = {
5155         /* front */
5156         0x02,
5157 };
5158
5159 static hda_nid_t alc260_adc_nids[1] = {
5160         /* ADC0 */
5161         0x04,
5162 };
5163
5164 static hda_nid_t alc260_adc_nids_alt[1] = {
5165         /* ADC1 */
5166         0x05,
5167 };
5168
5169 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5170  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5171  */
5172 static hda_nid_t alc260_dual_adc_nids[2] = {
5173         /* ADC0, ADC1 */
5174         0x04, 0x05
5175 };
5176
5177 #define ALC260_DIGOUT_NID       0x03
5178 #define ALC260_DIGIN_NID        0x06
5179
5180 static struct hda_input_mux alc260_capture_source = {
5181         .num_items = 4,
5182         .items = {
5183                 { "Mic", 0x0 },
5184                 { "Front Mic", 0x1 },
5185                 { "Line", 0x2 },
5186                 { "CD", 0x4 },
5187         },
5188 };
5189
5190 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5191  * headphone jack and the internal CD lines since these are the only pins at
5192  * which audio can appear.  For flexibility, also allow the option of
5193  * recording the mixer output on the second ADC (ADC0 doesn't have a
5194  * connection to the mixer output).
5195  */
5196 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5197         {
5198                 .num_items = 3,
5199                 .items = {
5200                         { "Mic/Line", 0x0 },
5201                         { "CD", 0x4 },
5202                         { "Headphone", 0x2 },
5203                 },
5204         },
5205         {
5206                 .num_items = 4,
5207                 .items = {
5208                         { "Mic/Line", 0x0 },
5209                         { "CD", 0x4 },
5210                         { "Headphone", 0x2 },
5211                         { "Mixer", 0x5 },
5212                 },
5213         },
5214
5215 };
5216
5217 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5218  * the Fujitsu S702x, but jacks are marked differently.
5219  */
5220 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5221         {
5222                 .num_items = 4,
5223                 .items = {
5224                         { "Mic", 0x0 },
5225                         { "Line", 0x2 },
5226                         { "CD", 0x4 },
5227                         { "Headphone", 0x5 },
5228                 },
5229         },
5230         {
5231                 .num_items = 5,
5232                 .items = {
5233                         { "Mic", 0x0 },
5234                         { "Line", 0x2 },
5235                         { "CD", 0x4 },
5236                         { "Headphone", 0x6 },
5237                         { "Mixer", 0x5 },
5238                 },
5239         },
5240 };
5241
5242 /* Maxdata Favorit 100XS */
5243 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5244         {
5245                 .num_items = 2,
5246                 .items = {
5247                         { "Line/Mic", 0x0 },
5248                         { "CD", 0x4 },
5249                 },
5250         },
5251         {
5252                 .num_items = 3,
5253                 .items = {
5254                         { "Line/Mic", 0x0 },
5255                         { "CD", 0x4 },
5256                         { "Mixer", 0x5 },
5257                 },
5258         },
5259 };
5260
5261 /*
5262  * This is just place-holder, so there's something for alc_build_pcms to look
5263  * at when it calculates the maximum number of channels. ALC260 has no mixer
5264  * element which allows changing the channel mode, so the verb list is
5265  * never used.
5266  */
5267 static struct hda_channel_mode alc260_modes[1] = {
5268         { 2, NULL },
5269 };
5270
5271
5272 /* Mixer combinations
5273  *
5274  * basic: base_output + input + pc_beep + capture
5275  * HP: base_output + input + capture_alt
5276  * HP_3013: hp_3013 + input + capture
5277  * fujitsu: fujitsu + capture
5278  * acer: acer + capture
5279  */
5280
5281 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5282         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5283         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5284         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5285         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5286         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5287         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5288         { } /* end */
5289 };
5290
5291 static struct snd_kcontrol_new alc260_input_mixer[] = {
5292         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5293         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5294         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5295         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5296         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5297         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5298         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5299         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5300         { } /* end */
5301 };
5302
5303 /* update HP, line and mono out pins according to the master switch */
5304 static void alc260_hp_master_update(struct hda_codec *codec,
5305                                     hda_nid_t hp, hda_nid_t line,
5306                                     hda_nid_t mono)
5307 {
5308         struct alc_spec *spec = codec->spec;
5309         unsigned int val = spec->master_sw ? PIN_HP : 0;
5310         /* change HP and line-out pins */
5311         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5312                             val);
5313         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5314                             val);
5315         /* mono (speaker) depending on the HP jack sense */
5316         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5317         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5318                             val);
5319 }
5320
5321 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5322                                    struct snd_ctl_elem_value *ucontrol)
5323 {
5324         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5325         struct alc_spec *spec = codec->spec;
5326         *ucontrol->value.integer.value = spec->master_sw;
5327         return 0;
5328 }
5329
5330 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5331                                    struct snd_ctl_elem_value *ucontrol)
5332 {
5333         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5334         struct alc_spec *spec = codec->spec;
5335         int val = !!*ucontrol->value.integer.value;
5336         hda_nid_t hp, line, mono;
5337
5338         if (val == spec->master_sw)
5339                 return 0;
5340         spec->master_sw = val;
5341         hp = (kcontrol->private_value >> 16) & 0xff;
5342         line = (kcontrol->private_value >> 8) & 0xff;
5343         mono = kcontrol->private_value & 0xff;
5344         alc260_hp_master_update(codec, hp, line, mono);
5345         return 1;
5346 }
5347
5348 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5349         {
5350                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5351                 .name = "Master Playback Switch",
5352                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5353                 .info = snd_ctl_boolean_mono_info,
5354                 .get = alc260_hp_master_sw_get,
5355                 .put = alc260_hp_master_sw_put,
5356                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5357         },
5358         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5359         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5360         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5361         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5362         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5363                               HDA_OUTPUT),
5364         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5365         { } /* end */
5366 };
5367
5368 static struct hda_verb alc260_hp_unsol_verbs[] = {
5369         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5370         {},
5371 };
5372
5373 static void alc260_hp_automute(struct hda_codec *codec)
5374 {
5375         struct alc_spec *spec = codec->spec;
5376
5377         spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5378         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5379 }
5380
5381 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5382 {
5383         if ((res >> 26) == ALC880_HP_EVENT)
5384                 alc260_hp_automute(codec);
5385 }
5386
5387 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5388         {
5389                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5390                 .name = "Master Playback Switch",
5391                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5392                 .info = snd_ctl_boolean_mono_info,
5393                 .get = alc260_hp_master_sw_get,
5394                 .put = alc260_hp_master_sw_put,
5395                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5396         },
5397         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5398         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5399         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5400         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5401         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5402         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5403         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5404         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5405         { } /* end */
5406 };
5407
5408 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5409         .ops = &snd_hda_bind_vol,
5410         .values = {
5411                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5412                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5413                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5414                 0
5415         },
5416 };
5417
5418 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5419         .ops = &snd_hda_bind_sw,
5420         .values = {
5421                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5422                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5423                 0
5424         },
5425 };
5426
5427 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5428         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5429         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5430         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5431         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5432         { } /* end */
5433 };
5434
5435 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5436         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5437         {},
5438 };
5439
5440 static void alc260_hp_3013_automute(struct hda_codec *codec)
5441 {
5442         struct alc_spec *spec = codec->spec;
5443
5444         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
5445         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5446 }
5447
5448 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5449                                        unsigned int res)
5450 {
5451         if ((res >> 26) == ALC880_HP_EVENT)
5452                 alc260_hp_3013_automute(codec);
5453 }
5454
5455 static void alc260_hp_3012_automute(struct hda_codec *codec)
5456 {
5457         unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
5458
5459         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5460                             bits);
5461         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5462                             bits);
5463         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5464                             bits);
5465 }
5466
5467 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5468                                        unsigned int res)
5469 {
5470         if ((res >> 26) == ALC880_HP_EVENT)
5471                 alc260_hp_3012_automute(codec);
5472 }
5473
5474 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5475  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5476  */
5477 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5478         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5479         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5480         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5481         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5482         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5483         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5484         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5485         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5486         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5487         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5488         { } /* end */
5489 };
5490
5491 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5492  * versions of the ALC260 don't act on requests to enable mic bias from NID
5493  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5494  * datasheet doesn't mention this restriction.  At this stage it's not clear
5495  * whether this behaviour is intentional or is a hardware bug in chip
5496  * revisions available in early 2006.  Therefore for now allow the
5497  * "Headphone Jack Mode" control to span all choices, but if it turns out
5498  * that the lack of mic bias for this NID is intentional we could change the
5499  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5500  *
5501  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5502  * don't appear to make the mic bias available from the "line" jack, even
5503  * though the NID used for this jack (0x14) can supply it.  The theory is
5504  * that perhaps Acer have included blocking capacitors between the ALC260
5505  * and the output jack.  If this turns out to be the case for all such
5506  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5507  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5508  *
5509  * The C20x Tablet series have a mono internal speaker which is controlled
5510  * via the chip's Mono sum widget and pin complex, so include the necessary
5511  * controls for such models.  On models without a "mono speaker" the control
5512  * won't do anything.
5513  */
5514 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5515         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5516         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5517         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5518         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5519                               HDA_OUTPUT),
5520         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5521                            HDA_INPUT),
5522         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5523         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5524         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5525         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5526         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5527         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5528         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5529         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5530         { } /* end */
5531 };
5532
5533 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5534  */
5535 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5536         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5537         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5538         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5539         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5540         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5541         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5542         { } /* end */
5543 };
5544
5545 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5546  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5547  */
5548 static struct snd_kcontrol_new alc260_will_mixer[] = {
5549         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5550         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5551         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5552         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5553         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5554         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5555         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5556         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5557         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5558         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5559         { } /* end */
5560 };
5561
5562 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5563  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5564  */
5565 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5566         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5567         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5568         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5569         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5570         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5571         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
5572         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
5573         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5574         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5575         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5576         { } /* end */
5577 };
5578
5579 /*
5580  * initialization verbs
5581  */
5582 static struct hda_verb alc260_init_verbs[] = {
5583         /* Line In pin widget for input */
5584         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5585         /* CD pin widget for input */
5586         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5587         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5588         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5589         /* Mic2 (front panel) pin widget for input and vref at 80% */
5590         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5591         /* LINE-2 is used for line-out in rear */
5592         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5593         /* select line-out */
5594         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
5595         /* LINE-OUT pin */
5596         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5597         /* enable HP */
5598         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5599         /* enable Mono */
5600         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5601         /* mute capture amp left and right */
5602         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5603         /* set connection select to line in (default select for this ADC) */
5604         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5605         /* mute capture amp left and right */
5606         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5607         /* set connection select to line in (default select for this ADC) */
5608         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
5609         /* set vol=0 Line-Out mixer amp left and right */
5610         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5611         /* unmute pin widget amp left and right (no gain on this amp) */
5612         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5613         /* set vol=0 HP mixer amp left and right */
5614         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5615         /* unmute pin widget amp left and right (no gain on this amp) */
5616         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5617         /* set vol=0 Mono mixer amp left and right */
5618         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5619         /* unmute pin widget amp left and right (no gain on this amp) */
5620         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5621         /* unmute LINE-2 out pin */
5622         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5623         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5624          * Line In 2 = 0x03
5625          */
5626         /* mute analog inputs */
5627         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5628         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5629         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5630         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5631         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5632         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5633         /* mute Front out path */
5634         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5635         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5636         /* mute Headphone out path */
5637         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5638         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5639         /* mute Mono out path */
5640         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5641         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5642         { }
5643 };
5644
5645 #if 0 /* should be identical with alc260_init_verbs? */
5646 static struct hda_verb alc260_hp_init_verbs[] = {
5647         /* Headphone and output */
5648         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5649         /* mono output */
5650         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5651         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5652         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5653         /* Mic2 (front panel) pin widget for input and vref at 80% */
5654         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5655         /* Line In pin widget for input */
5656         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5657         /* Line-2 pin widget for output */
5658         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5659         /* CD pin widget for input */
5660         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5661         /* unmute amp left and right */
5662         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5663         /* set connection select to line in (default select for this ADC) */
5664         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5665         /* unmute Line-Out mixer amp left and right (volume = 0) */
5666         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5667         /* mute pin widget amp left and right (no gain on this amp) */
5668         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5669         /* unmute HP mixer amp left and right (volume = 0) */
5670         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5671         /* mute pin widget amp left and right (no gain on this amp) */
5672         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5673         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5674          * Line In 2 = 0x03
5675          */
5676         /* mute analog inputs */
5677         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5678         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5679         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5680         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5681         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5682         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5683         /* Unmute Front out path */
5684         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5685         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5686         /* Unmute Headphone out path */
5687         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5688         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5689         /* Unmute Mono out path */
5690         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5691         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5692         { }
5693 };
5694 #endif
5695
5696 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5697         /* Line out and output */
5698         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5699         /* mono output */
5700         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5701         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5702         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5703         /* Mic2 (front panel) pin widget for input and vref at 80% */
5704         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5705         /* Line In pin widget for input */
5706         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5707         /* Headphone pin widget for output */
5708         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5709         /* CD pin widget for input */
5710         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5711         /* unmute amp left and right */
5712         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5713         /* set connection select to line in (default select for this ADC) */
5714         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5715         /* unmute Line-Out mixer amp left and right (volume = 0) */
5716         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5717         /* mute pin widget amp left and right (no gain on this amp) */
5718         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5719         /* unmute HP mixer amp left and right (volume = 0) */
5720         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5721         /* mute pin widget amp left and right (no gain on this amp) */
5722         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5723         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5724          * Line In 2 = 0x03
5725          */
5726         /* mute analog inputs */
5727         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5728         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5729         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5730         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5731         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5732         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5733         /* Unmute Front out path */
5734         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5735         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5736         /* Unmute Headphone out path */
5737         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5738         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5739         /* Unmute Mono out path */
5740         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5741         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5742         { }
5743 };
5744
5745 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5746  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5747  * audio = 0x16, internal speaker = 0x10.
5748  */
5749 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5750         /* Disable all GPIOs */
5751         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5752         /* Internal speaker is connected to headphone pin */
5753         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5754         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5755         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5756         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5757         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5758         /* Ensure all other unused pins are disabled and muted. */
5759         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5760         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5761         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5762         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5763         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5764         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5765         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5766         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5767
5768         /* Disable digital (SPDIF) pins */
5769         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5770         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5771
5772         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5773          * when acting as an output.
5774          */
5775         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5776
5777         /* Start with output sum widgets muted and their output gains at min */
5778         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5779         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5780         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5781         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5782         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5783         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5784         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5785         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5786         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5787
5788         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5789         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5790         /* Unmute Line1 pin widget output buffer since it starts as an output.
5791          * If the pin mode is changed by the user the pin mode control will
5792          * take care of enabling the pin's input/output buffers as needed.
5793          * Therefore there's no need to enable the input buffer at this
5794          * stage.
5795          */
5796         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5797         /* Unmute input buffer of pin widget used for Line-in (no equiv
5798          * mixer ctrl)
5799          */
5800         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5801
5802         /* Mute capture amp left and right */
5803         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5804         /* Set ADC connection select to match default mixer setting - line
5805          * in (on mic1 pin)
5806          */
5807         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5808
5809         /* Do the same for the second ADC: mute capture input amp and
5810          * set ADC connection to line in (on mic1 pin)
5811          */
5812         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5813         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5814
5815         /* Mute all inputs to mixer widget (even unconnected ones) */
5816         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5817         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5818         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5819         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5820         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5821         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5822         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5823         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5824
5825         { }
5826 };
5827
5828 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5829  * similar laptops (adapted from Fujitsu init verbs).
5830  */
5831 static struct hda_verb alc260_acer_init_verbs[] = {
5832         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5833          * the headphone jack.  Turn this on and rely on the standard mute
5834          * methods whenever the user wants to turn these outputs off.
5835          */
5836         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5837         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5838         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5839         /* Internal speaker/Headphone jack is connected to Line-out pin */
5840         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5841         /* Internal microphone/Mic jack is connected to Mic1 pin */
5842         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5843         /* Line In jack is connected to Line1 pin */
5844         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5845         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5846         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5847         /* Ensure all other unused pins are disabled and muted. */
5848         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5849         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5850         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5851         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5852         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5853         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5854         /* Disable digital (SPDIF) pins */
5855         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5856         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5857
5858         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5859          * bus when acting as outputs.
5860          */
5861         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5862         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5863
5864         /* Start with output sum widgets muted and their output gains at min */
5865         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5866         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5867         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5868         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5869         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5870         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5871         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5872         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5873         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5874
5875         /* Unmute Line-out pin widget amp left and right
5876          * (no equiv mixer ctrl)
5877          */
5878         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5879         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5880         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5881         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5882          * inputs. If the pin mode is changed by the user the pin mode control
5883          * will take care of enabling the pin's input/output buffers as needed.
5884          * Therefore there's no need to enable the input buffer at this
5885          * stage.
5886          */
5887         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5888         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5889
5890         /* Mute capture amp left and right */
5891         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5892         /* Set ADC connection select to match default mixer setting - mic
5893          * (on mic1 pin)
5894          */
5895         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5896
5897         /* Do similar with the second ADC: mute capture input amp and
5898          * set ADC connection to mic to match ALSA's default state.
5899          */
5900         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5901         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5902
5903         /* Mute all inputs to mixer widget (even unconnected ones) */
5904         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5905         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5906         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5907         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5908         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5909         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5910         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5911         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5912
5913         { }
5914 };
5915
5916 /* Initialisation sequence for Maxdata Favorit 100XS
5917  * (adapted from Acer init verbs).
5918  */
5919 static struct hda_verb alc260_favorit100_init_verbs[] = {
5920         /* GPIO 0 enables the output jack.
5921          * Turn this on and rely on the standard mute
5922          * methods whenever the user wants to turn these outputs off.
5923          */
5924         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5925         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5926         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5927         /* Line/Mic input jack is connected to Mic1 pin */
5928         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5929         /* Ensure all other unused pins are disabled and muted. */
5930         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5931         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5932         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5933         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5934         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5935         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5936         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5937         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5938         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5939         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5940         /* Disable digital (SPDIF) pins */
5941         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5942         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5943
5944         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5945          * bus when acting as outputs.
5946          */
5947         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5948         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5949
5950         /* Start with output sum widgets muted and their output gains at min */
5951         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5952         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5953         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5954         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5955         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5956         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5957         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5958         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5959         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5960
5961         /* Unmute Line-out pin widget amp left and right
5962          * (no equiv mixer ctrl)
5963          */
5964         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5965         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5966          * inputs. If the pin mode is changed by the user the pin mode control
5967          * will take care of enabling the pin's input/output buffers as needed.
5968          * Therefore there's no need to enable the input buffer at this
5969          * stage.
5970          */
5971         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5972
5973         /* Mute capture amp left and right */
5974         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5975         /* Set ADC connection select to match default mixer setting - mic
5976          * (on mic1 pin)
5977          */
5978         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5979
5980         /* Do similar with the second ADC: mute capture input amp and
5981          * set ADC connection to mic to match ALSA's default state.
5982          */
5983         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5984         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5985
5986         /* Mute all inputs to mixer widget (even unconnected ones) */
5987         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5988         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5989         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5990         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5991         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5992         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5993         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5994         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5995
5996         { }
5997 };
5998
5999 static struct hda_verb alc260_will_verbs[] = {
6000         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6001         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6002         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6003         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6004         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6005         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6006         {}
6007 };
6008
6009 static struct hda_verb alc260_replacer_672v_verbs[] = {
6010         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6011         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6012         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6013
6014         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6015         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6016         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6017
6018         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6019         {}
6020 };
6021
6022 /* toggle speaker-output according to the hp-jack state */
6023 static void alc260_replacer_672v_automute(struct hda_codec *codec)
6024 {
6025         unsigned int present;
6026
6027         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6028         present = snd_hda_jack_detect(codec, 0x0f);
6029         if (present) {
6030                 snd_hda_codec_write_cache(codec, 0x01, 0,
6031                                           AC_VERB_SET_GPIO_DATA, 1);
6032                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6033                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6034                                           PIN_HP);
6035         } else {
6036                 snd_hda_codec_write_cache(codec, 0x01, 0,
6037                                           AC_VERB_SET_GPIO_DATA, 0);
6038                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6039                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6040                                           PIN_OUT);
6041         }
6042 }
6043
6044 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6045                                        unsigned int res)
6046 {
6047         if ((res >> 26) == ALC880_HP_EVENT)
6048                 alc260_replacer_672v_automute(codec);
6049 }
6050
6051 static struct hda_verb alc260_hp_dc7600_verbs[] = {
6052         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6053         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6054         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6055         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6056         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6057         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6058         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6059         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6060         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6061         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6062         {}
6063 };
6064
6065 /* Test configuration for debugging, modelled after the ALC880 test
6066  * configuration.
6067  */
6068 #ifdef CONFIG_SND_DEBUG
6069 static hda_nid_t alc260_test_dac_nids[1] = {
6070         0x02,
6071 };
6072 static hda_nid_t alc260_test_adc_nids[2] = {
6073         0x04, 0x05,
6074 };
6075 /* For testing the ALC260, each input MUX needs its own definition since
6076  * the signal assignments are different.  This assumes that the first ADC
6077  * is NID 0x04.
6078  */
6079 static struct hda_input_mux alc260_test_capture_sources[2] = {
6080         {
6081                 .num_items = 7,
6082                 .items = {
6083                         { "MIC1 pin", 0x0 },
6084                         { "MIC2 pin", 0x1 },
6085                         { "LINE1 pin", 0x2 },
6086                         { "LINE2 pin", 0x3 },
6087                         { "CD pin", 0x4 },
6088                         { "LINE-OUT pin", 0x5 },
6089                         { "HP-OUT pin", 0x6 },
6090                 },
6091         },
6092         {
6093                 .num_items = 8,
6094                 .items = {
6095                         { "MIC1 pin", 0x0 },
6096                         { "MIC2 pin", 0x1 },
6097                         { "LINE1 pin", 0x2 },
6098                         { "LINE2 pin", 0x3 },
6099                         { "CD pin", 0x4 },
6100                         { "Mixer", 0x5 },
6101                         { "LINE-OUT pin", 0x6 },
6102                         { "HP-OUT pin", 0x7 },
6103                 },
6104         },
6105 };
6106 static struct snd_kcontrol_new alc260_test_mixer[] = {
6107         /* Output driver widgets */
6108         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6109         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6110         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6111         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6112         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6113         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6114
6115         /* Modes for retasking pin widgets
6116          * Note: the ALC260 doesn't seem to act on requests to enable mic
6117          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6118          * mention this restriction.  At this stage it's not clear whether
6119          * this behaviour is intentional or is a hardware bug in chip
6120          * revisions available at least up until early 2006.  Therefore for
6121          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6122          * choices, but if it turns out that the lack of mic bias for these
6123          * NIDs is intentional we could change their modes from
6124          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6125          */
6126         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6127         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6128         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
6129         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
6130         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
6131         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
6132
6133         /* Loopback mixer controls */
6134         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
6135         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
6136         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
6137         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
6138         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
6139         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
6140         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
6141         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
6142         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6143         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6144         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
6145         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
6146         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
6147         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
6148
6149         /* Controls for GPIO pins, assuming they are configured as outputs */
6150         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
6151         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
6152         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
6153         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
6154
6155         /* Switches to allow the digital IO pins to be enabled.  The datasheet
6156          * is ambigious as to which NID is which; testing on laptops which
6157          * make this output available should provide clarification.
6158          */
6159         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
6160         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
6161
6162         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
6163          * this output to turn on an external amplifier.
6164          */
6165         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
6166         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
6167
6168         { } /* end */
6169 };
6170 static struct hda_verb alc260_test_init_verbs[] = {
6171         /* Enable all GPIOs as outputs with an initial value of 0 */
6172         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6173         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6174         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6175
6176         /* Enable retasking pins as output, initially without power amp */
6177         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6178         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6179         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6180         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6181         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6182         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6183
6184         /* Disable digital (SPDIF) pins initially, but users can enable
6185          * them via a mixer switch.  In the case of SPDIF-out, this initverb
6186          * payload also sets the generation to 0, output to be in "consumer"
6187          * PCM format, copyright asserted, no pre-emphasis and no validity
6188          * control.
6189          */
6190         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6191         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6192
6193         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6194          * OUT1 sum bus when acting as an output.
6195          */
6196         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6197         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6198         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6199         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6200
6201         /* Start with output sum widgets muted and their output gains at min */
6202         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6203         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6204         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6205         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6206         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6207         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6208         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6209         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6210         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6211
6212         /* Unmute retasking pin widget output buffers since the default
6213          * state appears to be output.  As the pin mode is changed by the
6214          * user the pin mode control will take care of enabling the pin's
6215          * input/output buffers as needed.
6216          */
6217         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6218         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6219         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6220         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6221         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6222         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6223         /* Also unmute the mono-out pin widget */
6224         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6225
6226         /* Mute capture amp left and right */
6227         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6228         /* Set ADC connection select to match default mixer setting (mic1
6229          * pin)
6230          */
6231         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6232
6233         /* Do the same for the second ADC: mute capture input amp and
6234          * set ADC connection to mic1 pin
6235          */
6236         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6237         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6238
6239         /* Mute all inputs to mixer widget (even unconnected ones) */
6240         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6241         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6242         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6243         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6244         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6245         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6246         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6247         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6248
6249         { }
6250 };
6251 #endif
6252
6253 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
6254 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
6255
6256 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
6257 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
6258
6259 /*
6260  * for BIOS auto-configuration
6261  */
6262
6263 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6264                                         const char *pfx, int *vol_bits)
6265 {
6266         hda_nid_t nid_vol;
6267         unsigned long vol_val, sw_val;
6268         int err;
6269
6270         if (nid >= 0x0f && nid < 0x11) {
6271                 nid_vol = nid - 0x7;
6272                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6273                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6274         } else if (nid == 0x11) {
6275                 nid_vol = nid - 0x7;
6276                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6277                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6278         } else if (nid >= 0x12 && nid <= 0x15) {
6279                 nid_vol = 0x08;
6280                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6281                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6282         } else
6283                 return 0; /* N/A */
6284
6285         if (!(*vol_bits & (1 << nid_vol))) {
6286                 /* first control for the volume widget */
6287                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6288                 if (err < 0)
6289                         return err;
6290                 *vol_bits |= (1 << nid_vol);
6291         }
6292         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6293         if (err < 0)
6294                 return err;
6295         return 1;
6296 }
6297
6298 /* add playback controls from the parsed DAC table */
6299 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6300                                              const struct auto_pin_cfg *cfg)
6301 {
6302         hda_nid_t nid;
6303         int err;
6304         int vols = 0;
6305
6306         spec->multiout.num_dacs = 1;
6307         spec->multiout.dac_nids = spec->private_dac_nids;
6308         spec->multiout.dac_nids[0] = 0x02;
6309
6310         nid = cfg->line_out_pins[0];
6311         if (nid) {
6312                 const char *pfx;
6313                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6314                         pfx = "Master";
6315                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6316                         pfx = "Speaker";
6317                 else
6318                         pfx = "Front";
6319                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6320                 if (err < 0)
6321                         return err;
6322         }
6323
6324         nid = cfg->speaker_pins[0];
6325         if (nid) {
6326                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6327                 if (err < 0)
6328                         return err;
6329         }
6330
6331         nid = cfg->hp_pins[0];
6332         if (nid) {
6333                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6334                                                    &vols);
6335                 if (err < 0)
6336                         return err;
6337         }
6338         return 0;
6339 }
6340
6341 /* create playback/capture controls for input pins */
6342 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6343                                                 const struct auto_pin_cfg *cfg)
6344 {
6345         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6346 }
6347
6348 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6349                                               hda_nid_t nid, int pin_type,
6350                                               int sel_idx)
6351 {
6352         alc_set_pin_output(codec, nid, pin_type);
6353         /* need the manual connection? */
6354         if (nid >= 0x12) {
6355                 int idx = nid - 0x12;
6356                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6357                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6358         }
6359 }
6360
6361 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6362 {
6363         struct alc_spec *spec = codec->spec;
6364         hda_nid_t nid;
6365
6366         nid = spec->autocfg.line_out_pins[0];
6367         if (nid) {
6368                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6369                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6370         }
6371
6372         nid = spec->autocfg.speaker_pins[0];
6373         if (nid)
6374                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6375
6376         nid = spec->autocfg.hp_pins[0];
6377         if (nid)
6378                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6379 }
6380
6381 #define ALC260_PIN_CD_NID               0x16
6382 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6383 {
6384         struct alc_spec *spec = codec->spec;
6385         int i;
6386
6387         for (i = 0; i < AUTO_PIN_LAST; i++) {
6388                 hda_nid_t nid = spec->autocfg.input_pins[i];
6389                 if (nid >= 0x12) {
6390                         alc_set_input_pin(codec, nid, i);
6391                         if (nid != ALC260_PIN_CD_NID &&
6392                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6393                                 snd_hda_codec_write(codec, nid, 0,
6394                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6395                                                     AMP_OUT_MUTE);
6396                 }
6397         }
6398 }
6399
6400 /*
6401  * generic initialization of ADC, input mixers and output mixers
6402  */
6403 static struct hda_verb alc260_volume_init_verbs[] = {
6404         /*
6405          * Unmute ADC0-1 and set the default input to mic-in
6406          */
6407         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6408         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6409         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6410         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6411
6412         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6413          * mixer widget
6414          * Note: PASD motherboards uses the Line In 2 as the input for
6415          * front panel mic (mic 2)
6416          */
6417         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6418         /* mute analog inputs */
6419         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6420         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6421         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6422         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6423         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6424
6425         /*
6426          * Set up output mixers (0x08 - 0x0a)
6427          */
6428         /* set vol=0 to output mixers */
6429         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6430         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6431         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6432         /* set up input amps for analog loopback */
6433         /* Amp Indices: DAC = 0, mixer = 1 */
6434         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6435         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6436         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6437         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6438         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6439         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6440
6441         { }
6442 };
6443
6444 static int alc260_parse_auto_config(struct hda_codec *codec)
6445 {
6446         struct alc_spec *spec = codec->spec;
6447         int err;
6448         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6449
6450         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6451                                            alc260_ignore);
6452         if (err < 0)
6453                 return err;
6454         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6455         if (err < 0)
6456                 return err;
6457         if (!spec->kctls.list)
6458                 return 0; /* can't find valid BIOS pin config */
6459         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
6460         if (err < 0)
6461                 return err;
6462
6463         spec->multiout.max_channels = 2;
6464
6465         if (spec->autocfg.dig_outs)
6466                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6467         if (spec->kctls.list)
6468                 add_mixer(spec, spec->kctls.list);
6469
6470         add_verb(spec, alc260_volume_init_verbs);
6471
6472         spec->num_mux_defs = 1;
6473         spec->input_mux = &spec->private_imux[0];
6474
6475         alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
6476
6477         return 1;
6478 }
6479
6480 /* additional initialization for auto-configuration model */
6481 static void alc260_auto_init(struct hda_codec *codec)
6482 {
6483         struct alc_spec *spec = codec->spec;
6484         alc260_auto_init_multi_out(codec);
6485         alc260_auto_init_analog_input(codec);
6486         if (spec->unsol_event)
6487                 alc_inithook(codec);
6488 }
6489
6490 #ifdef CONFIG_SND_HDA_POWER_SAVE
6491 static struct hda_amp_list alc260_loopbacks[] = {
6492         { 0x07, HDA_INPUT, 0 },
6493         { 0x07, HDA_INPUT, 1 },
6494         { 0x07, HDA_INPUT, 2 },
6495         { 0x07, HDA_INPUT, 3 },
6496         { 0x07, HDA_INPUT, 4 },
6497         { } /* end */
6498 };
6499 #endif
6500
6501 /*
6502  * ALC260 configurations
6503  */
6504 static const char *alc260_models[ALC260_MODEL_LAST] = {
6505         [ALC260_BASIC]          = "basic",
6506         [ALC260_HP]             = "hp",
6507         [ALC260_HP_3013]        = "hp-3013",
6508         [ALC260_HP_DC7600]      = "hp-dc7600",
6509         [ALC260_FUJITSU_S702X]  = "fujitsu",
6510         [ALC260_ACER]           = "acer",
6511         [ALC260_WILL]           = "will",
6512         [ALC260_REPLACER_672V]  = "replacer",
6513         [ALC260_FAVORIT100]     = "favorit100",
6514 #ifdef CONFIG_SND_DEBUG
6515         [ALC260_TEST]           = "test",
6516 #endif
6517         [ALC260_AUTO]           = "auto",
6518 };
6519
6520 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6521         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6522         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
6523         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6524         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6525         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6526         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
6527         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6528         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6529         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6530         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6531         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6532         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6533         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6534         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6535         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6536         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6537         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6538         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6539         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6540         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6541         {}
6542 };
6543
6544 static struct alc_config_preset alc260_presets[] = {
6545         [ALC260_BASIC] = {
6546                 .mixers = { alc260_base_output_mixer,
6547                             alc260_input_mixer },
6548                 .init_verbs = { alc260_init_verbs },
6549                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6550                 .dac_nids = alc260_dac_nids,
6551                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6552                 .adc_nids = alc260_dual_adc_nids,
6553                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6554                 .channel_mode = alc260_modes,
6555                 .input_mux = &alc260_capture_source,
6556         },
6557         [ALC260_HP] = {
6558                 .mixers = { alc260_hp_output_mixer,
6559                             alc260_input_mixer },
6560                 .init_verbs = { alc260_init_verbs,
6561                                 alc260_hp_unsol_verbs },
6562                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6563                 .dac_nids = alc260_dac_nids,
6564                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6565                 .adc_nids = alc260_adc_nids_alt,
6566                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6567                 .channel_mode = alc260_modes,
6568                 .input_mux = &alc260_capture_source,
6569                 .unsol_event = alc260_hp_unsol_event,
6570                 .init_hook = alc260_hp_automute,
6571         },
6572         [ALC260_HP_DC7600] = {
6573                 .mixers = { alc260_hp_dc7600_mixer,
6574                             alc260_input_mixer },
6575                 .init_verbs = { alc260_init_verbs,
6576                                 alc260_hp_dc7600_verbs },
6577                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6578                 .dac_nids = alc260_dac_nids,
6579                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6580                 .adc_nids = alc260_adc_nids_alt,
6581                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6582                 .channel_mode = alc260_modes,
6583                 .input_mux = &alc260_capture_source,
6584                 .unsol_event = alc260_hp_3012_unsol_event,
6585                 .init_hook = alc260_hp_3012_automute,
6586         },
6587         [ALC260_HP_3013] = {
6588                 .mixers = { alc260_hp_3013_mixer,
6589                             alc260_input_mixer },
6590                 .init_verbs = { alc260_hp_3013_init_verbs,
6591                                 alc260_hp_3013_unsol_verbs },
6592                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6593                 .dac_nids = alc260_dac_nids,
6594                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6595                 .adc_nids = alc260_adc_nids_alt,
6596                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6597                 .channel_mode = alc260_modes,
6598                 .input_mux = &alc260_capture_source,
6599                 .unsol_event = alc260_hp_3013_unsol_event,
6600                 .init_hook = alc260_hp_3013_automute,
6601         },
6602         [ALC260_FUJITSU_S702X] = {
6603                 .mixers = { alc260_fujitsu_mixer },
6604                 .init_verbs = { alc260_fujitsu_init_verbs },
6605                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6606                 .dac_nids = alc260_dac_nids,
6607                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6608                 .adc_nids = alc260_dual_adc_nids,
6609                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6610                 .channel_mode = alc260_modes,
6611                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
6612                 .input_mux = alc260_fujitsu_capture_sources,
6613         },
6614         [ALC260_ACER] = {
6615                 .mixers = { alc260_acer_mixer },
6616                 .init_verbs = { alc260_acer_init_verbs },
6617                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6618                 .dac_nids = alc260_dac_nids,
6619                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6620                 .adc_nids = alc260_dual_adc_nids,
6621                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6622                 .channel_mode = alc260_modes,
6623                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
6624                 .input_mux = alc260_acer_capture_sources,
6625         },
6626         [ALC260_FAVORIT100] = {
6627                 .mixers = { alc260_favorit100_mixer },
6628                 .init_verbs = { alc260_favorit100_init_verbs },
6629                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6630                 .dac_nids = alc260_dac_nids,
6631                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6632                 .adc_nids = alc260_dual_adc_nids,
6633                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6634                 .channel_mode = alc260_modes,
6635                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6636                 .input_mux = alc260_favorit100_capture_sources,
6637         },
6638         [ALC260_WILL] = {
6639                 .mixers = { alc260_will_mixer },
6640                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
6641                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6642                 .dac_nids = alc260_dac_nids,
6643                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6644                 .adc_nids = alc260_adc_nids,
6645                 .dig_out_nid = ALC260_DIGOUT_NID,
6646                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6647                 .channel_mode = alc260_modes,
6648                 .input_mux = &alc260_capture_source,
6649         },
6650         [ALC260_REPLACER_672V] = {
6651                 .mixers = { alc260_replacer_672v_mixer },
6652                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6653                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6654                 .dac_nids = alc260_dac_nids,
6655                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6656                 .adc_nids = alc260_adc_nids,
6657                 .dig_out_nid = ALC260_DIGOUT_NID,
6658                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6659                 .channel_mode = alc260_modes,
6660                 .input_mux = &alc260_capture_source,
6661                 .unsol_event = alc260_replacer_672v_unsol_event,
6662                 .init_hook = alc260_replacer_672v_automute,
6663         },
6664 #ifdef CONFIG_SND_DEBUG
6665         [ALC260_TEST] = {
6666                 .mixers = { alc260_test_mixer },
6667                 .init_verbs = { alc260_test_init_verbs },
6668                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6669                 .dac_nids = alc260_test_dac_nids,
6670                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6671                 .adc_nids = alc260_test_adc_nids,
6672                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6673                 .channel_mode = alc260_modes,
6674                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6675                 .input_mux = alc260_test_capture_sources,
6676         },
6677 #endif
6678 };
6679
6680 static int patch_alc260(struct hda_codec *codec)
6681 {
6682         struct alc_spec *spec;
6683         int err, board_config;
6684
6685         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6686         if (spec == NULL)
6687                 return -ENOMEM;
6688
6689         codec->spec = spec;
6690
6691         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6692                                                   alc260_models,
6693                                                   alc260_cfg_tbl);
6694         if (board_config < 0) {
6695                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6696                            codec->chip_name);
6697                 board_config = ALC260_AUTO;
6698         }
6699
6700         if (board_config == ALC260_AUTO) {
6701                 /* automatic parse from the BIOS config */
6702                 err = alc260_parse_auto_config(codec);
6703                 if (err < 0) {
6704                         alc_free(codec);
6705                         return err;
6706                 } else if (!err) {
6707                         printk(KERN_INFO
6708                                "hda_codec: Cannot set up configuration "
6709                                "from BIOS.  Using base mode...\n");
6710                         board_config = ALC260_BASIC;
6711                 }
6712         }
6713
6714         err = snd_hda_attach_beep_device(codec, 0x1);
6715         if (err < 0) {
6716                 alc_free(codec);
6717                 return err;
6718         }
6719
6720         if (board_config != ALC260_AUTO)
6721                 setup_preset(codec, &alc260_presets[board_config]);
6722
6723         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6724         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6725
6726         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6727         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6728
6729         if (!spec->adc_nids && spec->input_mux) {
6730                 /* check whether NID 0x04 is valid */
6731                 unsigned int wcap = get_wcaps(codec, 0x04);
6732                 wcap = get_wcaps_type(wcap);
6733                 /* get type */
6734                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6735                         spec->adc_nids = alc260_adc_nids_alt;
6736                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6737                 } else {
6738                         spec->adc_nids = alc260_adc_nids;
6739                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6740                 }
6741         }
6742         set_capture_mixer(codec);
6743         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6744
6745         spec->vmaster_nid = 0x08;
6746
6747         codec->patch_ops = alc_patch_ops;
6748         if (board_config == ALC260_AUTO)
6749                 spec->init_hook = alc260_auto_init;
6750 #ifdef CONFIG_SND_HDA_POWER_SAVE
6751         if (!spec->loopback.amplist)
6752                 spec->loopback.amplist = alc260_loopbacks;
6753 #endif
6754
6755         return 0;
6756 }
6757
6758
6759 /*
6760  * ALC882/883/885/888/889 support
6761  *
6762  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6763  * configuration.  Each pin widget can choose any input DACs and a mixer.
6764  * Each ADC is connected from a mixer of all inputs.  This makes possible
6765  * 6-channel independent captures.
6766  *
6767  * In addition, an independent DAC for the multi-playback (not used in this
6768  * driver yet).
6769  */
6770 #define ALC882_DIGOUT_NID       0x06
6771 #define ALC882_DIGIN_NID        0x0a
6772 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
6773 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
6774 #define ALC1200_DIGOUT_NID      0x10
6775
6776
6777 static struct hda_channel_mode alc882_ch_modes[1] = {
6778         { 8, NULL }
6779 };
6780
6781 /* DACs */
6782 static hda_nid_t alc882_dac_nids[4] = {
6783         /* front, rear, clfe, rear_surr */
6784         0x02, 0x03, 0x04, 0x05
6785 };
6786 #define alc883_dac_nids         alc882_dac_nids
6787
6788 /* ADCs */
6789 #define alc882_adc_nids         alc880_adc_nids
6790 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6791 #define alc883_adc_nids         alc882_adc_nids_alt
6792 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
6793 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
6794 #define alc889_adc_nids         alc880_adc_nids
6795
6796 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6797 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6798 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
6799 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
6800 #define alc889_capsrc_nids      alc882_capsrc_nids
6801
6802 /* input MUX */
6803 /* FIXME: should be a matrix-type input source selection */
6804
6805 static struct hda_input_mux alc882_capture_source = {
6806         .num_items = 4,
6807         .items = {
6808                 { "Mic", 0x0 },
6809                 { "Front Mic", 0x1 },
6810                 { "Line", 0x2 },
6811                 { "CD", 0x4 },
6812         },
6813 };
6814
6815 #define alc883_capture_source   alc882_capture_source
6816
6817 static struct hda_input_mux alc889_capture_source = {
6818         .num_items = 3,
6819         .items = {
6820                 { "Front Mic", 0x0 },
6821                 { "Mic", 0x3 },
6822                 { "Line", 0x2 },
6823         },
6824 };
6825
6826 static struct hda_input_mux mb5_capture_source = {
6827         .num_items = 3,
6828         .items = {
6829                 { "Mic", 0x1 },
6830                 { "Line", 0x2 },
6831                 { "CD", 0x4 },
6832         },
6833 };
6834
6835 static struct hda_input_mux macmini3_capture_source = {
6836         .num_items = 2,
6837         .items = {
6838                 { "Line", 0x2 },
6839                 { "CD", 0x4 },
6840         },
6841 };
6842
6843 static struct hda_input_mux alc883_3stack_6ch_intel = {
6844         .num_items = 4,
6845         .items = {
6846                 { "Mic", 0x1 },
6847                 { "Front Mic", 0x0 },
6848                 { "Line", 0x2 },
6849                 { "CD", 0x4 },
6850         },
6851 };
6852
6853 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6854         .num_items = 2,
6855         .items = {
6856                 { "Mic", 0x1 },
6857                 { "Line", 0x2 },
6858         },
6859 };
6860
6861 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6862         .num_items = 4,
6863         .items = {
6864                 { "Mic", 0x0 },
6865                 { "iMic", 0x1 },
6866                 { "Line", 0x2 },
6867                 { "CD", 0x4 },
6868         },
6869 };
6870
6871 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6872         .num_items = 2,
6873         .items = {
6874                 { "Mic", 0x0 },
6875                 { "Int Mic", 0x1 },
6876         },
6877 };
6878
6879 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6880         .num_items = 3,
6881         .items = {
6882                 { "Mic", 0x0 },
6883                 { "Front Mic", 0x1 },
6884                 { "Line", 0x4 },
6885         },
6886 };
6887
6888 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6889         .num_items = 2,
6890         .items = {
6891                 { "Mic", 0x0 },
6892                 { "Line", 0x2 },
6893         },
6894 };
6895
6896 static struct hda_input_mux alc889A_mb31_capture_source = {
6897         .num_items = 2,
6898         .items = {
6899                 { "Mic", 0x0 },
6900                 /* Front Mic (0x01) unused */
6901                 { "Line", 0x2 },
6902                 /* Line 2 (0x03) unused */
6903                 /* CD (0x04) unused? */
6904         },
6905 };
6906
6907 /*
6908  * 2ch mode
6909  */
6910 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6911         { 2, NULL }
6912 };
6913
6914 /*
6915  * 2ch mode
6916  */
6917 static struct hda_verb alc882_3ST_ch2_init[] = {
6918         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6919         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6920         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6921         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6922         { } /* end */
6923 };
6924
6925 /*
6926  * 4ch mode
6927  */
6928 static struct hda_verb alc882_3ST_ch4_init[] = {
6929         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6930         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6931         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6932         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6933         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6934         { } /* end */
6935 };
6936
6937 /*
6938  * 6ch mode
6939  */
6940 static struct hda_verb alc882_3ST_ch6_init[] = {
6941         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6942         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6943         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6944         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6945         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6946         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6947         { } /* end */
6948 };
6949
6950 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
6951         { 2, alc882_3ST_ch2_init },
6952         { 4, alc882_3ST_ch4_init },
6953         { 6, alc882_3ST_ch6_init },
6954 };
6955
6956 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
6957
6958 /*
6959  * 2ch mode
6960  */
6961 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
6962         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
6963         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6964         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6965         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6966         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6967         { } /* end */
6968 };
6969
6970 /*
6971  * 4ch mode
6972  */
6973 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
6974         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6975         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6976         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6977         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6978         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6979         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6980         { } /* end */
6981 };
6982
6983 /*
6984  * 6ch mode
6985  */
6986 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
6987         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6988         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6989         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6990         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6991         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6992         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6993         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6994         { } /* end */
6995 };
6996
6997 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
6998         { 2, alc883_3ST_ch2_clevo_init },
6999         { 4, alc883_3ST_ch4_clevo_init },
7000         { 6, alc883_3ST_ch6_clevo_init },
7001 };
7002
7003
7004 /*
7005  * 6ch mode
7006  */
7007 static struct hda_verb alc882_sixstack_ch6_init[] = {
7008         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7009         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7010         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7011         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7012         { } /* end */
7013 };
7014
7015 /*
7016  * 8ch mode
7017  */
7018 static struct hda_verb alc882_sixstack_ch8_init[] = {
7019         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7020         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7021         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7022         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7023         { } /* end */
7024 };
7025
7026 static struct hda_channel_mode alc882_sixstack_modes[2] = {
7027         { 6, alc882_sixstack_ch6_init },
7028         { 8, alc882_sixstack_ch8_init },
7029 };
7030
7031
7032 /* Macbook Air 2,1 */
7033
7034 static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7035       { 2, NULL },
7036 };
7037
7038 /*
7039  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7040  */
7041
7042 /*
7043  * 2ch mode
7044  */
7045 static struct hda_verb alc885_mbp_ch2_init[] = {
7046         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7047         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7048         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7049         { } /* end */
7050 };
7051
7052 /*
7053  * 4ch mode
7054  */
7055 static struct hda_verb alc885_mbp_ch4_init[] = {
7056         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7057         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7058         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7059         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7060         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7061         { } /* end */
7062 };
7063
7064 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7065         { 2, alc885_mbp_ch2_init },
7066         { 4, alc885_mbp_ch4_init },
7067 };
7068
7069 /*
7070  * 2ch
7071  * Speakers/Woofer/HP = Front
7072  * LineIn = Input
7073  */
7074 static struct hda_verb alc885_mb5_ch2_init[] = {
7075         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7076         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7077         { } /* end */
7078 };
7079
7080 /*
7081  * 6ch mode
7082  * Speakers/HP = Front
7083  * Woofer = LFE
7084  * LineIn = Surround
7085  */
7086 static struct hda_verb alc885_mb5_ch6_init[] = {
7087         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7088         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7089         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7090         { } /* end */
7091 };
7092
7093 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
7094         { 2, alc885_mb5_ch2_init },
7095         { 6, alc885_mb5_ch6_init },
7096 };
7097
7098 #define alc885_macmini3_6ch_modes       alc885_mb5_6ch_modes
7099
7100 /*
7101  * 2ch mode
7102  */
7103 static struct hda_verb alc883_4ST_ch2_init[] = {
7104         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7105         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7106         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7107         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7108         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7109         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7110         { } /* end */
7111 };
7112
7113 /*
7114  * 4ch mode
7115  */
7116 static struct hda_verb alc883_4ST_ch4_init[] = {
7117         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7118         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7119         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7120         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7121         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7122         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7123         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7124         { } /* end */
7125 };
7126
7127 /*
7128  * 6ch mode
7129  */
7130 static struct hda_verb alc883_4ST_ch6_init[] = {
7131         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7132         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7133         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7134         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7135         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7136         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7137         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7138         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7139         { } /* end */
7140 };
7141
7142 /*
7143  * 8ch mode
7144  */
7145 static struct hda_verb alc883_4ST_ch8_init[] = {
7146         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7147         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7148         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7149         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7150         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7151         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7152         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7153         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7154         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7155         { } /* end */
7156 };
7157
7158 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
7159         { 2, alc883_4ST_ch2_init },
7160         { 4, alc883_4ST_ch4_init },
7161         { 6, alc883_4ST_ch6_init },
7162         { 8, alc883_4ST_ch8_init },
7163 };
7164
7165
7166 /*
7167  * 2ch mode
7168  */
7169 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7170         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7171         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7172         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7173         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7174         { } /* end */
7175 };
7176
7177 /*
7178  * 4ch mode
7179  */
7180 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7181         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7182         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7183         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7184         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7185         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7186         { } /* end */
7187 };
7188
7189 /*
7190  * 6ch mode
7191  */
7192 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7193         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7194         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7195         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7196         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7197         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7198         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7199         { } /* end */
7200 };
7201
7202 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7203         { 2, alc883_3ST_ch2_intel_init },
7204         { 4, alc883_3ST_ch4_intel_init },
7205         { 6, alc883_3ST_ch6_intel_init },
7206 };
7207
7208 /*
7209  * 2ch mode
7210  */
7211 static struct hda_verb alc889_ch2_intel_init[] = {
7212         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7213         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7214         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7215         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7216         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7217         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7218         { } /* end */
7219 };
7220
7221 /*
7222  * 6ch mode
7223  */
7224 static struct hda_verb alc889_ch6_intel_init[] = {
7225         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7226         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7227         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7228         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7229         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7230         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7231         { } /* end */
7232 };
7233
7234 /*
7235  * 8ch mode
7236  */
7237 static struct hda_verb alc889_ch8_intel_init[] = {
7238         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7239         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7240         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7241         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7242         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7243         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7244         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7245         { } /* end */
7246 };
7247
7248 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7249         { 2, alc889_ch2_intel_init },
7250         { 6, alc889_ch6_intel_init },
7251         { 8, alc889_ch8_intel_init },
7252 };
7253
7254 /*
7255  * 6ch mode
7256  */
7257 static struct hda_verb alc883_sixstack_ch6_init[] = {
7258         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7259         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7260         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7261         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7262         { } /* end */
7263 };
7264
7265 /*
7266  * 8ch mode
7267  */
7268 static struct hda_verb alc883_sixstack_ch8_init[] = {
7269         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7270         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7271         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7272         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7273         { } /* end */
7274 };
7275
7276 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7277         { 6, alc883_sixstack_ch6_init },
7278         { 8, alc883_sixstack_ch8_init },
7279 };
7280
7281
7282 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7283  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7284  */
7285 static struct snd_kcontrol_new alc882_base_mixer[] = {
7286         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7287         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7288         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7289         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7290         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7291         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7292         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7293         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7294         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7295         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7296         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7297         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7298         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7299         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7300         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7301         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7302         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7303         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7304         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7305         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7306         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7307         { } /* end */
7308 };
7309
7310 /* Macbook Air 2,1 same control for HP and internal Speaker */
7311
7312 static struct snd_kcontrol_new alc885_mba21_mixer[] = {
7313       HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7314       HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
7315      { }
7316 };
7317
7318
7319 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7320         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7321         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7322         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7323         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7324         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7325         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7326         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7327         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7328         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7329         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7330         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7331         { } /* end */
7332 };
7333
7334 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7335         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7336         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7337         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7338         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7339         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7340         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7341         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7342         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7343         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7344         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7345         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7346         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7347         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7348         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7349         { } /* end */
7350 };
7351
7352 static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
7353         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7354         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7355         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7356         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7357         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7358         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7359         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7360         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7361         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7362         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7363         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7364         { } /* end */
7365 };
7366
7367 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7368         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7369         HDA_BIND_MUTE   ("Line-Out Playback Switch", 0x0c, 0x02, HDA_INPUT),
7370         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
7371         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7372         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7373         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7374         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7375         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7376         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7377         { } /* end */
7378 };
7379
7380
7381 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7382         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7383         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7384         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7385         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7386         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7387         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7388         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7389         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7390         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7391         { } /* end */
7392 };
7393
7394 static struct snd_kcontrol_new alc882_targa_mixer[] = {
7395         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7396         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7397         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7398         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7399         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7400         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7401         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7402         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7403         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7404         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7405         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7406         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7407         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7408         { } /* end */
7409 };
7410
7411 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
7412  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
7413  */
7414 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
7415         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7416         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7417         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7418         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
7419         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7420         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7421         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7422         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7423         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
7424         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
7425         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7426         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7427         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7428         { } /* end */
7429 };
7430
7431 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7432         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7433         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7434         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7435         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7436         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7437         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7438         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7439         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7440         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7441         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7442         { } /* end */
7443 };
7444
7445 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7446         {
7447                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7448                 .name = "Channel Mode",
7449                 .info = alc_ch_mode_info,
7450                 .get = alc_ch_mode_get,
7451                 .put = alc_ch_mode_put,
7452         },
7453         { } /* end */
7454 };
7455
7456 static struct hda_verb alc882_base_init_verbs[] = {
7457         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7458         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7459         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7460         /* Rear mixer */
7461         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7462         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7463         /* CLFE mixer */
7464         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7465         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7466         /* Side mixer */
7467         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7468         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7469
7470         /* Front Pin: output 0 (0x0c) */
7471         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7472         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7473         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7474         /* Rear Pin: output 1 (0x0d) */
7475         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7476         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7477         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7478         /* CLFE Pin: output 2 (0x0e) */
7479         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7480         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7481         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7482         /* Side Pin: output 3 (0x0f) */
7483         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7484         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7485         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7486         /* Mic (rear) pin: input vref at 80% */
7487         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7488         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7489         /* Front Mic pin: input vref at 80% */
7490         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7491         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7492         /* Line In pin: input */
7493         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7494         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7495         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7496         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7497         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7498         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7499         /* CD pin widget for input */
7500         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7501
7502         /* FIXME: use matrix-type input source selection */
7503         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7504         /* Input mixer2 */
7505         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7506         /* Input mixer3 */
7507         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7508         /* ADC2: mute amp left and right */
7509         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7510         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7511         /* ADC3: mute amp left and right */
7512         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7513         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7514
7515         { }
7516 };
7517
7518 static struct hda_verb alc882_adc1_init_verbs[] = {
7519         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7520         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7521         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7522         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7523         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7524         /* ADC1: mute amp left and right */
7525         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7526         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7527         { }
7528 };
7529
7530 static struct hda_verb alc882_eapd_verbs[] = {
7531         /* change to EAPD mode */
7532         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7533         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
7534         { }
7535 };
7536
7537 static struct hda_verb alc889_eapd_verbs[] = {
7538         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
7539         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
7540         { }
7541 };
7542
7543 static struct hda_verb alc_hp15_unsol_verbs[] = {
7544         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
7545         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7546         {}
7547 };
7548
7549 static struct hda_verb alc885_init_verbs[] = {
7550         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7551         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7552         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7553         /* Rear mixer */
7554         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7555         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7556         /* CLFE mixer */
7557         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7558         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7559         /* Side mixer */
7560         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7561         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7562
7563         /* Front HP Pin: output 0 (0x0c) */
7564         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7565         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7566         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7567         /* Front Pin: output 0 (0x0c) */
7568         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7569         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7570         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7571         /* Rear Pin: output 1 (0x0d) */
7572         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7573         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7574         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
7575         /* CLFE Pin: output 2 (0x0e) */
7576         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7577         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7578         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7579         /* Side Pin: output 3 (0x0f) */
7580         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7581         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7582         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7583         /* Mic (rear) pin: input vref at 80% */
7584         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7585         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7586         /* Front Mic pin: input vref at 80% */
7587         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7588         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7589         /* Line In pin: input */
7590         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7591         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7592
7593         /* Mixer elements: 0x18, , 0x1a, 0x1b */
7594         /* Input mixer1 */
7595         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7596         /* Input mixer2 */
7597         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7598         /* Input mixer3 */
7599         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7600         /* ADC2: mute amp left and right */
7601         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7602         /* ADC3: mute amp left and right */
7603         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7604
7605         { }
7606 };
7607
7608 static struct hda_verb alc885_init_input_verbs[] = {
7609         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7610         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7611         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7612         { }
7613 };
7614
7615
7616 /* Unmute Selector 24h and set the default input to front mic */
7617 static struct hda_verb alc889_init_input_verbs[] = {
7618         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
7619         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7620         { }
7621 };
7622
7623
7624 #define alc883_init_verbs       alc882_base_init_verbs
7625
7626 /* Mac Pro test */
7627 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
7628         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7629         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7630         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
7631         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
7632         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
7633         /* FIXME: this looks suspicious...
7634         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
7635         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
7636         */
7637         { } /* end */
7638 };
7639
7640 static struct hda_verb alc882_macpro_init_verbs[] = {
7641         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7642         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7643         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7644         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7645         /* Front Pin: output 0 (0x0c) */
7646         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7647         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7648         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7649         /* Front Mic pin: input vref at 80% */
7650         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7651         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7652         /* Speaker:  output */
7653         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7654         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7655         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
7656         /* Headphone output (output 0 - 0x0c) */
7657         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7658         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7659         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7660
7661         /* FIXME: use matrix-type input source selection */
7662         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7663         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7664         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7665         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7666         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7667         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7668         /* Input mixer2 */
7669         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7670         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7671         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7672         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7673         /* Input mixer3 */
7674         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7675         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7676         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7677         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7678         /* ADC1: mute amp left and right */
7679         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7680         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7681         /* ADC2: mute amp left and right */
7682         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7683         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7684         /* ADC3: mute amp left and right */
7685         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7686         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7687
7688         { }
7689 };
7690
7691 /* Macbook 5,1 */
7692 static struct hda_verb alc885_mb5_init_verbs[] = {
7693         /* DACs */
7694         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7695         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7696         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7697         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7698         /* Front mixer */
7699         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7700         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7701         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7702         /* Surround mixer */
7703         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7704         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7705         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7706         /* LFE mixer */
7707         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7708         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7709         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7710         /* HP mixer */
7711         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7712         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7713         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7714         /* Front Pin (0x0c) */
7715         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7716         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7717         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7718         /* LFE Pin (0x0e) */
7719         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7720         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7721         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7722         /* HP Pin (0x0f) */
7723         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7724         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7725         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7726         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7727         /* Front Mic pin: input vref at 80% */
7728         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7729         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7730         /* Line In pin */
7731         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7732         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7733
7734         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7735         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7736         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7737         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7738         { }
7739 };
7740
7741 /* Macmini 3,1 */
7742 static struct hda_verb alc885_macmini3_init_verbs[] = {
7743         /* DACs */
7744         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7745         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7746         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7747         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7748         /* Front mixer */
7749         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7750         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7751         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7752         /* Surround mixer */
7753         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7754         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7755         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7756         /* LFE mixer */
7757         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7758         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7759         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7760         /* HP mixer */
7761         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7762         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7763         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7764         /* Front Pin (0x0c) */
7765         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7766         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7767         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7768         /* LFE Pin (0x0e) */
7769         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7770         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7771         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7772         /* HP Pin (0x0f) */
7773         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7774         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7775         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7776         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7777         /* Line In pin */
7778         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7779         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7780
7781         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7782         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7783         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7784         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7785         { }
7786 };
7787
7788
7789 static struct hda_verb alc885_mba21_init_verbs[] = {
7790         /*Internal and HP Speaker Mixer*/
7791         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7792         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7793         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7794         /*Internal Speaker Pin (0x0c)*/
7795         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
7796         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7797         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7798         /* HP Pin: output 0 (0x0e) */
7799         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7800         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7801         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7802         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
7803         /* Line in (is hp when jack connected)*/
7804         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
7805         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7806
7807         { }
7808  };
7809
7810
7811 /* Macbook Pro rev3 */
7812 static struct hda_verb alc885_mbp3_init_verbs[] = {
7813         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7814         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7815         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7816         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7817         /* Rear mixer */
7818         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7819         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7820         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7821         /* HP mixer */
7822         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7823         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7824         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7825         /* Front Pin: output 0 (0x0c) */
7826         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7827         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7828         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7829         /* HP Pin: output 0 (0x0e) */
7830         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7831         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7832         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
7833         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7834         /* Mic (rear) pin: input vref at 80% */
7835         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7836         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7837         /* Front Mic pin: input vref at 80% */
7838         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7839         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7840         /* Line In pin: use output 1 when in LineOut mode */
7841         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7842         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7843         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7844
7845         /* FIXME: use matrix-type input source selection */
7846         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7847         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7848         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7849         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7850         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7851         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7852         /* Input mixer2 */
7853         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7854         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7855         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7856         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7857         /* Input mixer3 */
7858         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7859         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7860         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7861         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7862         /* ADC1: mute amp left and right */
7863         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7864         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7865         /* ADC2: mute amp left and right */
7866         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7867         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7868         /* ADC3: mute amp left and right */
7869         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7870         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7871
7872         { }
7873 };
7874
7875 /* iMac 9,1 */
7876 static struct hda_verb alc885_imac91_init_verbs[] = {
7877         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
7878         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7879         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7880         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7881         /* Rear mixer */
7882         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7883         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7884         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7885         /* HP Pin: output 0 (0x0c) */
7886         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7887         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7888         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7889         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7890         /* Internal Speakers: output 0 (0x0d) */
7891         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7892         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7893         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7894         /* Mic (rear) pin: input vref at 80% */
7895         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7896         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7897         /* Front Mic pin: input vref at 80% */
7898         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7899         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7900         /* Line In pin: use output 1 when in LineOut mode */
7901         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7902         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7903         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7904
7905         /* FIXME: use matrix-type input source selection */
7906         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7907         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7908         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7909         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7910         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7911         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7912         /* Input mixer2 */
7913         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7914         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7915         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7916         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7917         /* Input mixer3 */
7918         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7919         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7920         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7921         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7922         /* ADC1: mute amp left and right */
7923         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7924         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7925         /* ADC2: mute amp left and right */
7926         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7927         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7928         /* ADC3: mute amp left and right */
7929         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7930         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7931
7932         { }
7933 };
7934
7935 /* iMac 24 mixer. */
7936 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
7937         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7938         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
7939         { } /* end */
7940 };
7941
7942 /* iMac 24 init verbs. */
7943 static struct hda_verb alc885_imac24_init_verbs[] = {
7944         /* Internal speakers: output 0 (0x0c) */
7945         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7946         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7947         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7948         /* Internal speakers: output 0 (0x0c) */
7949         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7950         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7951         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7952         /* Headphone: output 0 (0x0c) */
7953         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7954         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7955         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7956         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7957         /* Front Mic: input vref at 80% */
7958         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7959         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7960         { }
7961 };
7962
7963 /* Toggle speaker-output according to the hp-jack state */
7964 static void alc885_imac24_setup(struct hda_codec *codec)
7965 {
7966         struct alc_spec *spec = codec->spec;
7967
7968         spec->autocfg.hp_pins[0] = 0x14;
7969         spec->autocfg.speaker_pins[0] = 0x18;
7970         spec->autocfg.speaker_pins[1] = 0x1a;
7971 }
7972
7973 #define alc885_mb5_setup        alc885_imac24_setup
7974 #define alc885_macmini3_setup   alc885_imac24_setup
7975
7976 /* Macbook Air 2,1 */
7977 static void alc885_mba21_setup(struct hda_codec *codec)
7978 {
7979        struct alc_spec *spec = codec->spec;
7980
7981        spec->autocfg.hp_pins[0] = 0x14;
7982        spec->autocfg.speaker_pins[0] = 0x18;
7983 }
7984
7985
7986
7987 static void alc885_mbp3_setup(struct hda_codec *codec)
7988 {
7989         struct alc_spec *spec = codec->spec;
7990
7991         spec->autocfg.hp_pins[0] = 0x15;
7992         spec->autocfg.speaker_pins[0] = 0x14;
7993 }
7994
7995 static void alc885_imac91_setup(struct hda_codec *codec)
7996 {
7997         struct alc_spec *spec = codec->spec;
7998
7999         spec->autocfg.hp_pins[0] = 0x14;
8000         spec->autocfg.speaker_pins[0] = 0x15;
8001         spec->autocfg.speaker_pins[1] = 0x1a;
8002 }
8003
8004 static struct hda_verb alc882_targa_verbs[] = {
8005         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8006         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8007
8008         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8009         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8010
8011         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8012         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8013         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8014
8015         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8016         { } /* end */
8017 };
8018
8019 /* toggle speaker-output according to the hp-jack state */
8020 static void alc882_targa_automute(struct hda_codec *codec)
8021 {
8022         struct alc_spec *spec = codec->spec;
8023         alc_automute_amp(codec);
8024         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8025                                   spec->jack_present ? 1 : 3);
8026 }
8027
8028 static void alc882_targa_setup(struct hda_codec *codec)
8029 {
8030         struct alc_spec *spec = codec->spec;
8031
8032         spec->autocfg.hp_pins[0] = 0x14;
8033         spec->autocfg.speaker_pins[0] = 0x1b;
8034 }
8035
8036 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8037 {
8038         if ((res >> 26) == ALC880_HP_EVENT)
8039                 alc882_targa_automute(codec);
8040 }
8041
8042 static struct hda_verb alc882_asus_a7j_verbs[] = {
8043         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8044         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8045
8046         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8047         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8048         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8049
8050         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8051         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8052         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8053
8054         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8055         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8056         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8057         { } /* end */
8058 };
8059
8060 static struct hda_verb alc882_asus_a7m_verbs[] = {
8061         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8062         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8063
8064         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8065         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8066         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8067
8068         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8069         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8070         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8071
8072         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8073         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8074         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8075         { } /* end */
8076 };
8077
8078 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8079 {
8080         unsigned int gpiostate, gpiomask, gpiodir;
8081
8082         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8083                                        AC_VERB_GET_GPIO_DATA, 0);
8084
8085         if (!muted)
8086                 gpiostate |= (1 << pin);
8087         else
8088                 gpiostate &= ~(1 << pin);
8089
8090         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
8091                                       AC_VERB_GET_GPIO_MASK, 0);
8092         gpiomask |= (1 << pin);
8093
8094         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
8095                                      AC_VERB_GET_GPIO_DIRECTION, 0);
8096         gpiodir |= (1 << pin);
8097
8098
8099         snd_hda_codec_write(codec, codec->afg, 0,
8100                             AC_VERB_SET_GPIO_MASK, gpiomask);
8101         snd_hda_codec_write(codec, codec->afg, 0,
8102                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
8103
8104         msleep(1);
8105
8106         snd_hda_codec_write(codec, codec->afg, 0,
8107                             AC_VERB_SET_GPIO_DATA, gpiostate);
8108 }
8109
8110 /* set up GPIO at initialization */
8111 static void alc885_macpro_init_hook(struct hda_codec *codec)
8112 {
8113         alc882_gpio_mute(codec, 0, 0);
8114         alc882_gpio_mute(codec, 1, 0);
8115 }
8116
8117 /* set up GPIO and update auto-muting at initialization */
8118 static void alc885_imac24_init_hook(struct hda_codec *codec)
8119 {
8120         alc885_macpro_init_hook(codec);
8121         alc_automute_amp(codec);
8122 }
8123
8124 /*
8125  * generic initialization of ADC, input mixers and output mixers
8126  */
8127 static struct hda_verb alc883_auto_init_verbs[] = {
8128         /*
8129          * Unmute ADC0-2 and set the default input to mic-in
8130          */
8131         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8132         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8133         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8134         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8135
8136         /*
8137          * Set up output mixers (0x0c - 0x0f)
8138          */
8139         /* set vol=0 to output mixers */
8140         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8141         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8142         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8143         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8144         /* set up input amps for analog loopback */
8145         /* Amp Indices: DAC = 0, mixer = 1 */
8146         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8147         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8148         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8149         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8150         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8151         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8152         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8153         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8154         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8155         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8156
8157         /* FIXME: use matrix-type input source selection */
8158         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8159         /* Input mixer2 */
8160         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8161         /* Input mixer3 */
8162         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8163         { }
8164 };
8165
8166 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
8167 static struct hda_verb alc889A_mb31_ch2_init[] = {
8168         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8169         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8170         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8171         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8172         { } /* end */
8173 };
8174
8175 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
8176 static struct hda_verb alc889A_mb31_ch4_init[] = {
8177         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8178         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8179         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8180         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8181         { } /* end */
8182 };
8183
8184 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
8185 static struct hda_verb alc889A_mb31_ch5_init[] = {
8186         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
8187         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8188         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8189         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8190         { } /* end */
8191 };
8192
8193 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
8194 static struct hda_verb alc889A_mb31_ch6_init[] = {
8195         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
8196         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
8197         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8198         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8199         { } /* end */
8200 };
8201
8202 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
8203         { 2, alc889A_mb31_ch2_init },
8204         { 4, alc889A_mb31_ch4_init },
8205         { 5, alc889A_mb31_ch5_init },
8206         { 6, alc889A_mb31_ch6_init },
8207 };
8208
8209 static struct hda_verb alc883_medion_eapd_verbs[] = {
8210         /* eanable EAPD on medion laptop */
8211         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8212         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8213         { }
8214 };
8215
8216 #define alc883_base_mixer       alc882_base_mixer
8217
8218 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8219         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8220         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8221         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8222         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8223         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8224         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8225         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8226         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8227         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8228         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8229         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8230         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8231         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8232         { } /* end */
8233 };
8234
8235 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8236         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8237         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8238         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8239         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8240         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8241         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8242         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8243         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8244         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8245         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8246         { } /* end */
8247 };
8248
8249 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8250         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8251         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8252         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8253         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8254         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8255         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8256         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8257         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8258         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8259         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8260         { } /* end */
8261 };
8262
8263 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8264         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8265         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8266         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8267         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8268         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8269         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8270         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8271         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8272         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8273         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8274         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8275         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8276         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8277         { } /* end */
8278 };
8279
8280 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8281         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8282         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8283         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8284         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8285         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8286         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8287         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8288         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8289         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8290         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8291         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8292         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8293         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8294         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8295         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8296         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8297         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8298         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8299         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8300         { } /* end */
8301 };
8302
8303 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8304         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8305         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8306         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8307         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8308         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8309                               HDA_OUTPUT),
8310         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8311         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8312         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8313         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8314         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8315         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8316         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8317         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8318         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8319         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8320         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8321         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8322         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8323         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8324         { } /* end */
8325 };
8326
8327 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8328         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8329         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8330         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8331         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8332         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8333                               HDA_OUTPUT),
8334         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8335         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8336         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8337         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8338         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8339         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8340         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8341         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8342         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8343         HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
8344         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8345         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8346         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8347         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8348         { } /* end */
8349 };
8350
8351 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8352         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8353         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8354         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8355         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8356         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8357         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8358         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8359         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8360         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8361         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8362         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8363         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8364         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8365         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8366         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8367         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8368         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8369         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8370         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8371         { } /* end */
8372 };
8373
8374 static struct snd_kcontrol_new alc883_targa_mixer[] = {
8375         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8376         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8377         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8378         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8379         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8380         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8381         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8382         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8383         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8384         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8385         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8386         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8387         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8388         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8389         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8390         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8391         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8392         { } /* end */
8393 };
8394
8395 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
8396         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8397         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8398         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8399         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8400         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8401         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8402         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8403         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8404         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8405         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8406         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8407         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8408         { } /* end */
8409 };
8410
8411 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
8412         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8413         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8414         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8415         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8416         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8417         { } /* end */
8418 };
8419
8420 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
8421         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8422         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8423         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8424         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8425         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8426         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8427         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8428         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8429         { } /* end */
8430 };
8431
8432 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
8433         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8434         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
8435         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8436         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8437         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8438         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8439         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8440         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8441         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8442         { } /* end */
8443 };
8444
8445 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
8446         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8447         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8448         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8449         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8450         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8451         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8452         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8453         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8454         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8455         { } /* end */
8456 };
8457
8458 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
8459         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8460         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8461         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8462         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8463         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8464         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8465         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8466         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8467         { } /* end */
8468 };
8469
8470 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
8471         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8472         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8473         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8474         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8475         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8476         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8477         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8478         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8479         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8480         { } /* end */
8481 };
8482
8483 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
8484         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8485         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8486         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8487         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
8488         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
8489                                                 0x0d, 1, 0x0, HDA_OUTPUT),
8490         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
8491         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
8492         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
8493         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8494         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8495         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8496         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8497         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8498         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8499         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8500         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8501         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8502         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8503         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8504         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8505         { } /* end */
8506 };
8507
8508 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
8509         /* Output mixers */
8510         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8511         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8512         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8513         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8514         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
8515                 HDA_OUTPUT),
8516         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
8517         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
8518         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
8519         /* Output switches */
8520         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
8521         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
8522         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
8523         /* Boost mixers */
8524         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
8525         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
8526         /* Input mixers */
8527         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8528         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8529         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8530         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8531         { } /* end */
8532 };
8533
8534 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
8535         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8536         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8537         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8538         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8539         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8540         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8541         { } /* end */
8542 };
8543
8544 static struct hda_bind_ctls alc883_bind_cap_vol = {
8545         .ops = &snd_hda_bind_vol,
8546         .values = {
8547                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8548                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8549                 0
8550         },
8551 };
8552
8553 static struct hda_bind_ctls alc883_bind_cap_switch = {
8554         .ops = &snd_hda_bind_sw,
8555         .values = {
8556                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8557                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8558                 0
8559         },
8560 };
8561
8562 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
8563         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8564         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8565         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8566         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8567         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8568         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8569         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8570         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8571         { } /* end */
8572 };
8573
8574 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
8575         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
8576         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
8577         {
8578                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8579                 /* .name = "Capture Source", */
8580                 .name = "Input Source",
8581                 .count = 1,
8582                 .info = alc_mux_enum_info,
8583                 .get = alc_mux_enum_get,
8584                 .put = alc_mux_enum_put,
8585         },
8586         { } /* end */
8587 };
8588
8589 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
8590         {
8591                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8592                 .name = "Channel Mode",
8593                 .info = alc_ch_mode_info,
8594                 .get = alc_ch_mode_get,
8595                 .put = alc_ch_mode_put,
8596         },
8597         { } /* end */
8598 };
8599
8600 /* toggle speaker-output according to the hp-jack state */
8601 static void alc883_mitac_setup(struct hda_codec *codec)
8602 {
8603         struct alc_spec *spec = codec->spec;
8604
8605         spec->autocfg.hp_pins[0] = 0x15;
8606         spec->autocfg.speaker_pins[0] = 0x14;
8607         spec->autocfg.speaker_pins[1] = 0x17;
8608 }
8609
8610 /* auto-toggle front mic */
8611 /*
8612 static void alc883_mitac_mic_automute(struct hda_codec *codec)
8613 {
8614         unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0;
8615
8616         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
8617 }
8618 */
8619
8620 static struct hda_verb alc883_mitac_verbs[] = {
8621         /* HP */
8622         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8623         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8624         /* Subwoofer */
8625         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8626         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8627
8628         /* enable unsolicited event */
8629         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8630         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8631
8632         { } /* end */
8633 };
8634
8635 static struct hda_verb alc883_clevo_m540r_verbs[] = {
8636         /* HP */
8637         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8638         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8639         /* Int speaker */
8640         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
8641
8642         /* enable unsolicited event */
8643         /*
8644         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8645         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8646         */
8647
8648         { } /* end */
8649 };
8650
8651 static struct hda_verb alc883_clevo_m720_verbs[] = {
8652         /* HP */
8653         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8654         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8655         /* Int speaker */
8656         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
8657         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8658
8659         /* enable unsolicited event */
8660         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8661         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8662
8663         { } /* end */
8664 };
8665
8666 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8667         /* HP */
8668         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8669         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8670         /* Subwoofer */
8671         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8672         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8673
8674         /* enable unsolicited event */
8675         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8676
8677         { } /* end */
8678 };
8679
8680 static struct hda_verb alc883_targa_verbs[] = {
8681         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8682         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8683
8684         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8685         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8686
8687 /* Connect Line-Out side jack (SPDIF) to Side */
8688         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8689         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8690         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8691 /* Connect Mic jack to CLFE */
8692         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8693         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8694         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
8695 /* Connect Line-in jack to Surround */
8696         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8697         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8698         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8699 /* Connect HP out jack to Front */
8700         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8701         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8702         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8703
8704         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8705
8706         { } /* end */
8707 };
8708
8709 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8710         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8711         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8712         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8713         { } /* end */
8714 };
8715
8716 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8717         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8718         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8719         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8720         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8721         { } /* end */
8722 };
8723
8724 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8725         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8726         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8727         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8728         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8729         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8730         { } /* end */
8731 };
8732
8733 static struct hda_verb alc883_haier_w66_verbs[] = {
8734         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8735         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8736
8737         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8738
8739         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8740         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8741         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8742         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8743         { } /* end */
8744 };
8745
8746 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8747         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8748         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8749         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8750         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8751         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8752         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8753         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8754         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8755         { } /* end */
8756 };
8757
8758 static struct hda_verb alc888_6st_dell_verbs[] = {
8759         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8760         { }
8761 };
8762
8763 static struct hda_verb alc883_vaiott_verbs[] = {
8764         /* HP */
8765         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8766         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8767
8768         /* enable unsolicited event */
8769         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8770
8771         { } /* end */
8772 };
8773
8774 static void alc888_3st_hp_setup(struct hda_codec *codec)
8775 {
8776         struct alc_spec *spec = codec->spec;
8777
8778         spec->autocfg.hp_pins[0] = 0x1b;
8779         spec->autocfg.speaker_pins[0] = 0x14;
8780         spec->autocfg.speaker_pins[1] = 0x16;
8781         spec->autocfg.speaker_pins[2] = 0x18;
8782 }
8783
8784 static struct hda_verb alc888_3st_hp_verbs[] = {
8785         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8786         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8787         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8788         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8789         { } /* end */
8790 };
8791
8792 /*
8793  * 2ch mode
8794  */
8795 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8796         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8797         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8798         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8799         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8800         { } /* end */
8801 };
8802
8803 /*
8804  * 4ch mode
8805  */
8806 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8807         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8808         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8809         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8810         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8811         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8812         { } /* end */
8813 };
8814
8815 /*
8816  * 6ch mode
8817  */
8818 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8819         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8820         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8821         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8822         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8823         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8824         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8825         { } /* end */
8826 };
8827
8828 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8829         { 2, alc888_3st_hp_2ch_init },
8830         { 4, alc888_3st_hp_4ch_init },
8831         { 6, alc888_3st_hp_6ch_init },
8832 };
8833
8834 /* toggle front-jack and RCA according to the hp-jack state */
8835 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8836 {
8837         unsigned int present = snd_hda_jack_detect(codec, 0x1b);
8838
8839         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8840                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8841         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8842                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8843 }
8844
8845 /* toggle RCA according to the front-jack state */
8846 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8847 {
8848         unsigned int present = snd_hda_jack_detect(codec, 0x14);
8849
8850         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8851                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8852 }
8853
8854 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8855                                              unsigned int res)
8856 {
8857         if ((res >> 26) == ALC880_HP_EVENT)
8858                 alc888_lenovo_ms7195_front_automute(codec);
8859         if ((res >> 26) == ALC880_FRONT_EVENT)
8860                 alc888_lenovo_ms7195_rca_automute(codec);
8861 }
8862
8863 static struct hda_verb alc883_medion_md2_verbs[] = {
8864         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8865         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8866
8867         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8868
8869         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8870         { } /* end */
8871 };
8872
8873 /* toggle speaker-output according to the hp-jack state */
8874 static void alc883_medion_md2_setup(struct hda_codec *codec)
8875 {
8876         struct alc_spec *spec = codec->spec;
8877
8878         spec->autocfg.hp_pins[0] = 0x14;
8879         spec->autocfg.speaker_pins[0] = 0x15;
8880 }
8881
8882 /* toggle speaker-output according to the hp-jack state */
8883 #define alc883_targa_init_hook          alc882_targa_init_hook
8884 #define alc883_targa_unsol_event        alc882_targa_unsol_event
8885
8886 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8887 {
8888         unsigned int present;
8889
8890         present = snd_hda_jack_detect(codec, 0x18);
8891         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8892                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8893 }
8894
8895 static void alc883_clevo_m720_setup(struct hda_codec *codec)
8896 {
8897         struct alc_spec *spec = codec->spec;
8898
8899         spec->autocfg.hp_pins[0] = 0x15;
8900         spec->autocfg.speaker_pins[0] = 0x14;
8901 }
8902
8903 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8904 {
8905         alc_automute_amp(codec);
8906         alc883_clevo_m720_mic_automute(codec);
8907 }
8908
8909 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8910                                            unsigned int res)
8911 {
8912         switch (res >> 26) {
8913         case ALC880_MIC_EVENT:
8914                 alc883_clevo_m720_mic_automute(codec);
8915                 break;
8916         default:
8917                 alc_automute_amp_unsol_event(codec, res);
8918                 break;
8919         }
8920 }
8921
8922 /* toggle speaker-output according to the hp-jack state */
8923 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
8924 {
8925         struct alc_spec *spec = codec->spec;
8926
8927         spec->autocfg.hp_pins[0] = 0x14;
8928         spec->autocfg.speaker_pins[0] = 0x15;
8929 }
8930
8931 static void alc883_haier_w66_setup(struct hda_codec *codec)
8932 {
8933         struct alc_spec *spec = codec->spec;
8934
8935         spec->autocfg.hp_pins[0] = 0x1b;
8936         spec->autocfg.speaker_pins[0] = 0x14;
8937 }
8938
8939 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8940 {
8941         int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
8942
8943         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8944                                  HDA_AMP_MUTE, bits);
8945 }
8946
8947 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8948 {
8949         int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
8950
8951         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8952                                  HDA_AMP_MUTE, bits);
8953         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8954                                  HDA_AMP_MUTE, bits);
8955 }
8956
8957 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8958                                            unsigned int res)
8959 {
8960         if ((res >> 26) == ALC880_HP_EVENT)
8961                 alc883_lenovo_101e_all_automute(codec);
8962         if ((res >> 26) == ALC880_FRONT_EVENT)
8963                 alc883_lenovo_101e_ispeaker_automute(codec);
8964 }
8965
8966 /* toggle speaker-output according to the hp-jack state */
8967 static void alc883_acer_aspire_setup(struct hda_codec *codec)
8968 {
8969         struct alc_spec *spec = codec->spec;
8970
8971         spec->autocfg.hp_pins[0] = 0x14;
8972         spec->autocfg.speaker_pins[0] = 0x15;
8973         spec->autocfg.speaker_pins[1] = 0x16;
8974 }
8975
8976 static struct hda_verb alc883_acer_eapd_verbs[] = {
8977         /* HP Pin: output 0 (0x0c) */
8978         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8979         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8980         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8981         /* Front Pin: output 0 (0x0c) */
8982         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8983         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8984         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8985         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8986         /* eanable EAPD on medion laptop */
8987         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8988         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8989         /* enable unsolicited event */
8990         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8991         { }
8992 };
8993
8994 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
8995         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8996         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8997         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8998         { } /* end */
8999 };
9000
9001 static void alc888_6st_dell_setup(struct hda_codec *codec)
9002 {
9003         struct alc_spec *spec = codec->spec;
9004
9005         spec->autocfg.hp_pins[0] = 0x1b;
9006         spec->autocfg.speaker_pins[0] = 0x14;
9007         spec->autocfg.speaker_pins[1] = 0x15;
9008         spec->autocfg.speaker_pins[2] = 0x16;
9009         spec->autocfg.speaker_pins[3] = 0x17;
9010 }
9011
9012 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9013 {
9014         struct alc_spec *spec = codec->spec;
9015
9016         spec->autocfg.hp_pins[0] = 0x1b;
9017         spec->autocfg.speaker_pins[0] = 0x14;
9018         spec->autocfg.speaker_pins[1] = 0x15;
9019         spec->autocfg.speaker_pins[2] = 0x16;
9020         spec->autocfg.speaker_pins[3] = 0x17;
9021         spec->autocfg.speaker_pins[4] = 0x1a;
9022 }
9023
9024 static void alc883_vaiott_setup(struct hda_codec *codec)
9025 {
9026         struct alc_spec *spec = codec->spec;
9027
9028         spec->autocfg.hp_pins[0] = 0x15;
9029         spec->autocfg.speaker_pins[0] = 0x14;
9030         spec->autocfg.speaker_pins[1] = 0x17;
9031 }
9032
9033 static struct hda_verb alc888_asus_m90v_verbs[] = {
9034         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9035         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9036         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9037         /* enable unsolicited event */
9038         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9039         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9040         { } /* end */
9041 };
9042
9043 static void alc883_mode2_setup(struct hda_codec *codec)
9044 {
9045         struct alc_spec *spec = codec->spec;
9046
9047         spec->autocfg.hp_pins[0] = 0x1b;
9048         spec->autocfg.speaker_pins[0] = 0x14;
9049         spec->autocfg.speaker_pins[1] = 0x15;
9050         spec->autocfg.speaker_pins[2] = 0x16;
9051         spec->ext_mic.pin = 0x18;
9052         spec->int_mic.pin = 0x19;
9053         spec->ext_mic.mux_idx = 0;
9054         spec->int_mic.mux_idx = 1;
9055         spec->auto_mic = 1;
9056 }
9057
9058 static struct hda_verb alc888_asus_eee1601_verbs[] = {
9059         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9060         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9061         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9062         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9063         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9064         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9065         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9066         /* enable unsolicited event */
9067         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9068         { } /* end */
9069 };
9070
9071 static void alc883_eee1601_inithook(struct hda_codec *codec)
9072 {
9073         struct alc_spec *spec = codec->spec;
9074
9075         spec->autocfg.hp_pins[0] = 0x14;
9076         spec->autocfg.speaker_pins[0] = 0x1b;
9077         alc_automute_pin(codec);
9078 }
9079
9080 static struct hda_verb alc889A_mb31_verbs[] = {
9081         /* Init rear pin (used as headphone output) */
9082         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9083         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9084         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9085         /* Init line pin (used as output in 4ch and 6ch mode) */
9086         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9087         /* Init line 2 pin (used as headphone out by default) */
9088         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9089         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9090         { } /* end */
9091 };
9092
9093 /* Mute speakers according to the headphone jack state */
9094 static void alc889A_mb31_automute(struct hda_codec *codec)
9095 {
9096         unsigned int present;
9097
9098         /* Mute only in 2ch or 4ch mode */
9099         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9100             == 0x00) {
9101                 present = snd_hda_jack_detect(codec, 0x15);
9102                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9103                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9104                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9105                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9106         }
9107 }
9108
9109 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
9110 {
9111         if ((res >> 26) == ALC880_HP_EVENT)
9112                 alc889A_mb31_automute(codec);
9113 }
9114
9115
9116 #ifdef CONFIG_SND_HDA_POWER_SAVE
9117 #define alc882_loopbacks        alc880_loopbacks
9118 #endif
9119
9120 /* pcm configuration: identical with ALC880 */
9121 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
9122 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
9123 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
9124 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
9125
9126 static hda_nid_t alc883_slave_dig_outs[] = {
9127         ALC1200_DIGOUT_NID, 0,
9128 };
9129
9130 static hda_nid_t alc1200_slave_dig_outs[] = {
9131         ALC883_DIGOUT_NID, 0,
9132 };
9133
9134 /*
9135  * configuration and preset
9136  */
9137 static const char *alc882_models[ALC882_MODEL_LAST] = {
9138         [ALC882_3ST_DIG]        = "3stack-dig",
9139         [ALC882_6ST_DIG]        = "6stack-dig",
9140         [ALC882_ARIMA]          = "arima",
9141         [ALC882_W2JC]           = "w2jc",
9142         [ALC882_TARGA]          = "targa",
9143         [ALC882_ASUS_A7J]       = "asus-a7j",
9144         [ALC882_ASUS_A7M]       = "asus-a7m",
9145         [ALC885_MACPRO]         = "macpro",
9146         [ALC885_MB5]            = "mb5",
9147         [ALC885_MACMINI3]       = "macmini3",
9148         [ALC885_MBA21]          = "mba21",
9149         [ALC885_MBP3]           = "mbp3",
9150         [ALC885_IMAC24]         = "imac24",
9151         [ALC885_IMAC91]         = "imac91",
9152         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
9153         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
9154         [ALC883_3ST_6ch]        = "3stack-6ch",
9155         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
9156         [ALC883_TARGA_DIG]      = "targa-dig",
9157         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
9158         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
9159         [ALC883_ACER]           = "acer",
9160         [ALC883_ACER_ASPIRE]    = "acer-aspire",
9161         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
9162         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
9163         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
9164         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
9165         [ALC883_MEDION]         = "medion",
9166         [ALC883_MEDION_MD2]     = "medion-md2",
9167         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
9168         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
9169         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
9170         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
9171         [ALC888_LENOVO_SKY] = "lenovo-sky",
9172         [ALC883_HAIER_W66]      = "haier-w66",
9173         [ALC888_3ST_HP]         = "3stack-hp",
9174         [ALC888_6ST_DELL]       = "6stack-dell",
9175         [ALC883_MITAC]          = "mitac",
9176         [ALC883_CLEVO_M540R]    = "clevo-m540r",
9177         [ALC883_CLEVO_M720]     = "clevo-m720",
9178         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
9179         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
9180         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
9181         [ALC889A_INTEL]         = "intel-alc889a",
9182         [ALC889_INTEL]          = "intel-x58",
9183         [ALC1200_ASUS_P5Q]      = "asus-p5q",
9184         [ALC889A_MB31]          = "mb31",
9185         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
9186         [ALC882_AUTO]           = "auto",
9187 };
9188
9189 static struct snd_pci_quirk alc882_cfg_tbl[] = {
9190         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
9191
9192         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
9193         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
9194         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
9195         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
9196         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
9197         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
9198         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
9199                 ALC888_ACER_ASPIRE_4930G),
9200         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
9201                 ALC888_ACER_ASPIRE_4930G),
9202         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
9203                 ALC888_ACER_ASPIRE_8930G),
9204         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
9205                 ALC888_ACER_ASPIRE_8930G),
9206         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
9207         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9208         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9209                 ALC888_ACER_ASPIRE_6530G),
9210         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9211                 ALC888_ACER_ASPIRE_6530G),
9212         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9213                 ALC888_ACER_ASPIRE_7730G),
9214         /* default Acer -- disabled as it causes more problems.
9215          *    model=auto should work fine now
9216          */
9217         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9218
9219         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9220
9221         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9222         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9223         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9224         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9225         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9226         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9227
9228         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9229         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9230         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9231         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9232         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9233         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9234         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9235         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9236         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9237         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9238         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9239
9240         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9241         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9242         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9243         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9244         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9245         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9246         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9247         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9248         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9249
9250         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9251         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9252         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9253         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9254         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9255         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9256         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9257         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9258         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9259         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9260         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9261         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9262         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9263         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9264         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9265         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9266         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9267         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9268         SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
9269         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9270         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9271         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9272         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9273         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9274         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9275         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9276         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9277         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9278         SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
9279         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9280         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9281
9282         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9283         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9284         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9285         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9286         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9287         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9288         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9289         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9290         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9291                       ALC883_FUJITSU_PI2515),
9292         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9293                 ALC888_FUJITSU_XA3530),
9294         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9295         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9296         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9297         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9298         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9299         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
9300         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9301         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9302         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9303
9304         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9305         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9306         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9307         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9308         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9309         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9310         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
9311
9312         {}
9313 };
9314
9315 /* codec SSID table for Intel Mac */
9316 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9317         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9318         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9319         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9320         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9321         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9322         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9323         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9324         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9325         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9326         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9327         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9328         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9329         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9330          * so apparently no perfect solution yet
9331          */
9332         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9333         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9334         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
9335         {} /* terminator */
9336 };
9337
9338 static struct alc_config_preset alc882_presets[] = {
9339         [ALC882_3ST_DIG] = {
9340                 .mixers = { alc882_base_mixer },
9341                 .init_verbs = { alc882_base_init_verbs,
9342                                 alc882_adc1_init_verbs },
9343                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9344                 .dac_nids = alc882_dac_nids,
9345                 .dig_out_nid = ALC882_DIGOUT_NID,
9346                 .dig_in_nid = ALC882_DIGIN_NID,
9347                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9348                 .channel_mode = alc882_ch_modes,
9349                 .need_dac_fix = 1,
9350                 .input_mux = &alc882_capture_source,
9351         },
9352         [ALC882_6ST_DIG] = {
9353                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9354                 .init_verbs = { alc882_base_init_verbs,
9355                                 alc882_adc1_init_verbs },
9356                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9357                 .dac_nids = alc882_dac_nids,
9358                 .dig_out_nid = ALC882_DIGOUT_NID,
9359                 .dig_in_nid = ALC882_DIGIN_NID,
9360                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9361                 .channel_mode = alc882_sixstack_modes,
9362                 .input_mux = &alc882_capture_source,
9363         },
9364         [ALC882_ARIMA] = {
9365                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9366                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9367                                 alc882_eapd_verbs },
9368                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9369                 .dac_nids = alc882_dac_nids,
9370                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9371                 .channel_mode = alc882_sixstack_modes,
9372                 .input_mux = &alc882_capture_source,
9373         },
9374         [ALC882_W2JC] = {
9375                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9376                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9377                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
9378                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9379                 .dac_nids = alc882_dac_nids,
9380                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9381                 .channel_mode = alc880_threestack_modes,
9382                 .need_dac_fix = 1,
9383                 .input_mux = &alc882_capture_source,
9384                 .dig_out_nid = ALC882_DIGOUT_NID,
9385         },
9386            [ALC885_MBA21] = {
9387                         .mixers = { alc885_mba21_mixer },
9388                         .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
9389                         .num_dacs = 2,
9390                         .dac_nids = alc882_dac_nids,
9391                         .channel_mode = alc885_mba21_ch_modes,
9392                         .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
9393                         .input_mux = &alc882_capture_source,
9394                         .unsol_event = alc_automute_amp_unsol_event,
9395                         .setup = alc885_mba21_setup,
9396                         .init_hook = alc_automute_amp,
9397        },
9398         [ALC885_MBP3] = {
9399                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9400                 .init_verbs = { alc885_mbp3_init_verbs,
9401                                 alc880_gpio1_init_verbs },
9402                 .num_dacs = 2,
9403                 .dac_nids = alc882_dac_nids,
9404                 .hp_nid = 0x04,
9405                 .channel_mode = alc885_mbp_4ch_modes,
9406                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9407                 .input_mux = &alc882_capture_source,
9408                 .dig_out_nid = ALC882_DIGOUT_NID,
9409                 .dig_in_nid = ALC882_DIGIN_NID,
9410                 .unsol_event = alc_automute_amp_unsol_event,
9411                 .setup = alc885_mbp3_setup,
9412                 .init_hook = alc_automute_amp,
9413         },
9414         [ALC885_MB5] = {
9415                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
9416                 .init_verbs = { alc885_mb5_init_verbs,
9417                                 alc880_gpio1_init_verbs },
9418                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9419                 .dac_nids = alc882_dac_nids,
9420                 .channel_mode = alc885_mb5_6ch_modes,
9421                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
9422                 .input_mux = &mb5_capture_source,
9423                 .dig_out_nid = ALC882_DIGOUT_NID,
9424                 .dig_in_nid = ALC882_DIGIN_NID,
9425                 .unsol_event = alc_automute_amp_unsol_event,
9426                 .setup = alc885_mb5_setup,
9427                 .init_hook = alc_automute_amp,
9428         },
9429         [ALC885_MACMINI3] = {
9430                 .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
9431                 .init_verbs = { alc885_macmini3_init_verbs,
9432                                 alc880_gpio1_init_verbs },
9433                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9434                 .dac_nids = alc882_dac_nids,
9435                 .channel_mode = alc885_macmini3_6ch_modes,
9436                 .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
9437                 .input_mux = &macmini3_capture_source,
9438                 .dig_out_nid = ALC882_DIGOUT_NID,
9439                 .dig_in_nid = ALC882_DIGIN_NID,
9440                 .unsol_event = alc_automute_amp_unsol_event,
9441                 .setup = alc885_macmini3_setup,
9442                 .init_hook = alc_automute_amp,
9443         },
9444         [ALC885_MACPRO] = {
9445                 .mixers = { alc882_macpro_mixer },
9446                 .init_verbs = { alc882_macpro_init_verbs },
9447                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9448                 .dac_nids = alc882_dac_nids,
9449                 .dig_out_nid = ALC882_DIGOUT_NID,
9450                 .dig_in_nid = ALC882_DIGIN_NID,
9451                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9452                 .channel_mode = alc882_ch_modes,
9453                 .input_mux = &alc882_capture_source,
9454                 .init_hook = alc885_macpro_init_hook,
9455         },
9456         [ALC885_IMAC24] = {
9457                 .mixers = { alc885_imac24_mixer },
9458                 .init_verbs = { alc885_imac24_init_verbs },
9459                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9460                 .dac_nids = alc882_dac_nids,
9461                 .dig_out_nid = ALC882_DIGOUT_NID,
9462                 .dig_in_nid = ALC882_DIGIN_NID,
9463                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9464                 .channel_mode = alc882_ch_modes,
9465                 .input_mux = &alc882_capture_source,
9466                 .unsol_event = alc_automute_amp_unsol_event,
9467                 .setup = alc885_imac24_setup,
9468                 .init_hook = alc885_imac24_init_hook,
9469         },
9470         [ALC885_IMAC91] = {
9471                 .mixers = { alc885_imac91_mixer, alc882_chmode_mixer },
9472                 .init_verbs = { alc885_imac91_init_verbs,
9473                                 alc880_gpio1_init_verbs },
9474                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9475                 .dac_nids = alc882_dac_nids,
9476                 .channel_mode = alc885_mbp_4ch_modes,
9477                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9478                 .input_mux = &alc882_capture_source,
9479                 .dig_out_nid = ALC882_DIGOUT_NID,
9480                 .dig_in_nid = ALC882_DIGIN_NID,
9481                 .unsol_event = alc_automute_amp_unsol_event,
9482                 .setup = alc885_imac91_setup,
9483                 .init_hook = alc_automute_amp,
9484         },
9485         [ALC882_TARGA] = {
9486                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
9487                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9488                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
9489                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9490                 .dac_nids = alc882_dac_nids,
9491                 .dig_out_nid = ALC882_DIGOUT_NID,
9492                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9493                 .adc_nids = alc882_adc_nids,
9494                 .capsrc_nids = alc882_capsrc_nids,
9495                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9496                 .channel_mode = alc882_3ST_6ch_modes,
9497                 .need_dac_fix = 1,
9498                 .input_mux = &alc882_capture_source,
9499                 .unsol_event = alc882_targa_unsol_event,
9500                 .setup = alc882_targa_setup,
9501                 .init_hook = alc882_targa_automute,
9502         },
9503         [ALC882_ASUS_A7J] = {
9504                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
9505                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9506                                 alc882_asus_a7j_verbs},
9507                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9508                 .dac_nids = alc882_dac_nids,
9509                 .dig_out_nid = ALC882_DIGOUT_NID,
9510                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9511                 .adc_nids = alc882_adc_nids,
9512                 .capsrc_nids = alc882_capsrc_nids,
9513                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9514                 .channel_mode = alc882_3ST_6ch_modes,
9515                 .need_dac_fix = 1,
9516                 .input_mux = &alc882_capture_source,
9517         },
9518         [ALC882_ASUS_A7M] = {
9519                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
9520                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9521                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
9522                                 alc882_asus_a7m_verbs },
9523                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9524                 .dac_nids = alc882_dac_nids,
9525                 .dig_out_nid = ALC882_DIGOUT_NID,
9526                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9527                 .channel_mode = alc880_threestack_modes,
9528                 .need_dac_fix = 1,
9529                 .input_mux = &alc882_capture_source,
9530         },
9531         [ALC883_3ST_2ch_DIG] = {
9532                 .mixers = { alc883_3ST_2ch_mixer },
9533                 .init_verbs = { alc883_init_verbs },
9534                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9535                 .dac_nids = alc883_dac_nids,
9536                 .dig_out_nid = ALC883_DIGOUT_NID,
9537                 .dig_in_nid = ALC883_DIGIN_NID,
9538                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9539                 .channel_mode = alc883_3ST_2ch_modes,
9540                 .input_mux = &alc883_capture_source,
9541         },
9542         [ALC883_3ST_6ch_DIG] = {
9543                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9544                 .init_verbs = { alc883_init_verbs },
9545                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9546                 .dac_nids = alc883_dac_nids,
9547                 .dig_out_nid = ALC883_DIGOUT_NID,
9548                 .dig_in_nid = ALC883_DIGIN_NID,
9549                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9550                 .channel_mode = alc883_3ST_6ch_modes,
9551                 .need_dac_fix = 1,
9552                 .input_mux = &alc883_capture_source,
9553         },
9554         [ALC883_3ST_6ch] = {
9555                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9556                 .init_verbs = { alc883_init_verbs },
9557                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9558                 .dac_nids = alc883_dac_nids,
9559                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9560                 .channel_mode = alc883_3ST_6ch_modes,
9561                 .need_dac_fix = 1,
9562                 .input_mux = &alc883_capture_source,
9563         },
9564         [ALC883_3ST_6ch_INTEL] = {
9565                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
9566                 .init_verbs = { alc883_init_verbs },
9567                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9568                 .dac_nids = alc883_dac_nids,
9569                 .dig_out_nid = ALC883_DIGOUT_NID,
9570                 .dig_in_nid = ALC883_DIGIN_NID,
9571                 .slave_dig_outs = alc883_slave_dig_outs,
9572                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
9573                 .channel_mode = alc883_3ST_6ch_intel_modes,
9574                 .need_dac_fix = 1,
9575                 .input_mux = &alc883_3stack_6ch_intel,
9576         },
9577         [ALC889A_INTEL] = {
9578                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9579                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
9580                                 alc_hp15_unsol_verbs },
9581                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9582                 .dac_nids = alc883_dac_nids,
9583                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9584                 .adc_nids = alc889_adc_nids,
9585                 .dig_out_nid = ALC883_DIGOUT_NID,
9586                 .dig_in_nid = ALC883_DIGIN_NID,
9587                 .slave_dig_outs = alc883_slave_dig_outs,
9588                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9589                 .channel_mode = alc889_8ch_intel_modes,
9590                 .capsrc_nids = alc889_capsrc_nids,
9591                 .input_mux = &alc889_capture_source,
9592                 .setup = alc889_automute_setup,
9593                 .init_hook = alc_automute_amp,
9594                 .unsol_event = alc_automute_amp_unsol_event,
9595                 .need_dac_fix = 1,
9596         },
9597         [ALC889_INTEL] = {
9598                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9599                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
9600                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
9601                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9602                 .dac_nids = alc883_dac_nids,
9603                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9604                 .adc_nids = alc889_adc_nids,
9605                 .dig_out_nid = ALC883_DIGOUT_NID,
9606                 .dig_in_nid = ALC883_DIGIN_NID,
9607                 .slave_dig_outs = alc883_slave_dig_outs,
9608                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9609                 .channel_mode = alc889_8ch_intel_modes,
9610                 .capsrc_nids = alc889_capsrc_nids,
9611                 .input_mux = &alc889_capture_source,
9612                 .setup = alc889_automute_setup,
9613                 .init_hook = alc889_intel_init_hook,
9614                 .unsol_event = alc_automute_amp_unsol_event,
9615                 .need_dac_fix = 1,
9616         },
9617         [ALC883_6ST_DIG] = {
9618                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9619                 .init_verbs = { alc883_init_verbs },
9620                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9621                 .dac_nids = alc883_dac_nids,
9622                 .dig_out_nid = ALC883_DIGOUT_NID,
9623                 .dig_in_nid = ALC883_DIGIN_NID,
9624                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9625                 .channel_mode = alc883_sixstack_modes,
9626                 .input_mux = &alc883_capture_source,
9627         },
9628         [ALC883_TARGA_DIG] = {
9629                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
9630                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9631                                 alc883_targa_verbs},
9632                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9633                 .dac_nids = alc883_dac_nids,
9634                 .dig_out_nid = ALC883_DIGOUT_NID,
9635                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9636                 .channel_mode = alc883_3ST_6ch_modes,
9637                 .need_dac_fix = 1,
9638                 .input_mux = &alc883_capture_source,
9639                 .unsol_event = alc883_targa_unsol_event,
9640                 .setup = alc882_targa_setup,
9641                 .init_hook = alc882_targa_automute,
9642         },
9643         [ALC883_TARGA_2ch_DIG] = {
9644                 .mixers = { alc883_targa_2ch_mixer},
9645                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9646                                 alc883_targa_verbs},
9647                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9648                 .dac_nids = alc883_dac_nids,
9649                 .adc_nids = alc883_adc_nids_alt,
9650                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9651                 .capsrc_nids = alc883_capsrc_nids,
9652                 .dig_out_nid = ALC883_DIGOUT_NID,
9653                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9654                 .channel_mode = alc883_3ST_2ch_modes,
9655                 .input_mux = &alc883_capture_source,
9656                 .unsol_event = alc883_targa_unsol_event,
9657                 .setup = alc882_targa_setup,
9658                 .init_hook = alc882_targa_automute,
9659         },
9660         [ALC883_TARGA_8ch_DIG] = {
9661                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
9662                             alc883_chmode_mixer },
9663                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9664                                 alc883_targa_verbs },
9665                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9666                 .dac_nids = alc883_dac_nids,
9667                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9668                 .adc_nids = alc883_adc_nids_rev,
9669                 .capsrc_nids = alc883_capsrc_nids_rev,
9670                 .dig_out_nid = ALC883_DIGOUT_NID,
9671                 .dig_in_nid = ALC883_DIGIN_NID,
9672                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
9673                 .channel_mode = alc883_4ST_8ch_modes,
9674                 .need_dac_fix = 1,
9675                 .input_mux = &alc883_capture_source,
9676                 .unsol_event = alc883_targa_unsol_event,
9677                 .setup = alc882_targa_setup,
9678                 .init_hook = alc882_targa_automute,
9679         },
9680         [ALC883_ACER] = {
9681                 .mixers = { alc883_base_mixer },
9682                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
9683                  * and the headphone jack.  Turn this on and rely on the
9684                  * standard mute methods whenever the user wants to turn
9685                  * these outputs off.
9686                  */
9687                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
9688                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9689                 .dac_nids = alc883_dac_nids,
9690                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9691                 .channel_mode = alc883_3ST_2ch_modes,
9692                 .input_mux = &alc883_capture_source,
9693         },
9694         [ALC883_ACER_ASPIRE] = {
9695                 .mixers = { alc883_acer_aspire_mixer },
9696                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
9697                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9698                 .dac_nids = alc883_dac_nids,
9699                 .dig_out_nid = ALC883_DIGOUT_NID,
9700                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9701                 .channel_mode = alc883_3ST_2ch_modes,
9702                 .input_mux = &alc883_capture_source,
9703                 .unsol_event = alc_automute_amp_unsol_event,
9704                 .setup = alc883_acer_aspire_setup,
9705                 .init_hook = alc_automute_amp,
9706         },
9707         [ALC888_ACER_ASPIRE_4930G] = {
9708                 .mixers = { alc888_base_mixer,
9709                                 alc883_chmode_mixer },
9710                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9711                                 alc888_acer_aspire_4930g_verbs },
9712                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9713                 .dac_nids = alc883_dac_nids,
9714                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9715                 .adc_nids = alc883_adc_nids_rev,
9716                 .capsrc_nids = alc883_capsrc_nids_rev,
9717                 .dig_out_nid = ALC883_DIGOUT_NID,
9718                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9719                 .channel_mode = alc883_3ST_6ch_modes,
9720                 .need_dac_fix = 1,
9721                 .const_channel_count = 6,
9722                 .num_mux_defs =
9723                         ARRAY_SIZE(alc888_2_capture_sources),
9724                 .input_mux = alc888_2_capture_sources,
9725                 .unsol_event = alc_automute_amp_unsol_event,
9726                 .setup = alc888_acer_aspire_4930g_setup,
9727                 .init_hook = alc_automute_amp,
9728         },
9729         [ALC888_ACER_ASPIRE_6530G] = {
9730                 .mixers = { alc888_acer_aspire_6530_mixer },
9731                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9732                                 alc888_acer_aspire_6530g_verbs },
9733                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9734                 .dac_nids = alc883_dac_nids,
9735                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9736                 .adc_nids = alc883_adc_nids_rev,
9737                 .capsrc_nids = alc883_capsrc_nids_rev,
9738                 .dig_out_nid = ALC883_DIGOUT_NID,
9739                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9740                 .channel_mode = alc883_3ST_2ch_modes,
9741                 .num_mux_defs =
9742                         ARRAY_SIZE(alc888_2_capture_sources),
9743                 .input_mux = alc888_acer_aspire_6530_sources,
9744                 .unsol_event = alc_automute_amp_unsol_event,
9745                 .setup = alc888_acer_aspire_6530g_setup,
9746                 .init_hook = alc_automute_amp,
9747         },
9748         [ALC888_ACER_ASPIRE_8930G] = {
9749                 .mixers = { alc889_acer_aspire_8930g_mixer,
9750                                 alc883_chmode_mixer },
9751                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9752                                 alc889_acer_aspire_8930g_verbs,
9753                                 alc889_eapd_verbs},
9754                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9755                 .dac_nids = alc883_dac_nids,
9756                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9757                 .adc_nids = alc889_adc_nids,
9758                 .capsrc_nids = alc889_capsrc_nids,
9759                 .dig_out_nid = ALC883_DIGOUT_NID,
9760                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9761                 .channel_mode = alc883_3ST_6ch_modes,
9762                 .need_dac_fix = 1,
9763                 .const_channel_count = 6,
9764                 .num_mux_defs =
9765                         ARRAY_SIZE(alc889_capture_sources),
9766                 .input_mux = alc889_capture_sources,
9767                 .unsol_event = alc_automute_amp_unsol_event,
9768                 .setup = alc889_acer_aspire_8930g_setup,
9769                 .init_hook = alc_automute_amp,
9770 #ifdef CONFIG_SND_HDA_POWER_SAVE
9771                 .power_hook = alc_power_eapd,
9772 #endif
9773         },
9774         [ALC888_ACER_ASPIRE_7730G] = {
9775                 .mixers = { alc883_3ST_6ch_mixer,
9776                                 alc883_chmode_mixer },
9777                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9778                                 alc888_acer_aspire_7730G_verbs },
9779                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9780                 .dac_nids = alc883_dac_nids,
9781                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9782                 .adc_nids = alc883_adc_nids_rev,
9783                 .capsrc_nids = alc883_capsrc_nids_rev,
9784                 .dig_out_nid = ALC883_DIGOUT_NID,
9785                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9786                 .channel_mode = alc883_3ST_6ch_modes,
9787                 .need_dac_fix = 1,
9788                 .const_channel_count = 6,
9789                 .input_mux = &alc883_capture_source,
9790                 .unsol_event = alc_automute_amp_unsol_event,
9791                 .setup = alc888_acer_aspire_6530g_setup,
9792                 .init_hook = alc_automute_amp,
9793         },
9794         [ALC883_MEDION] = {
9795                 .mixers = { alc883_fivestack_mixer,
9796                             alc883_chmode_mixer },
9797                 .init_verbs = { alc883_init_verbs,
9798                                 alc883_medion_eapd_verbs },
9799                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9800                 .dac_nids = alc883_dac_nids,
9801                 .adc_nids = alc883_adc_nids_alt,
9802                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9803                 .capsrc_nids = alc883_capsrc_nids,
9804                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9805                 .channel_mode = alc883_sixstack_modes,
9806                 .input_mux = &alc883_capture_source,
9807         },
9808         [ALC883_MEDION_MD2] = {
9809                 .mixers = { alc883_medion_md2_mixer},
9810                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
9811                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9812                 .dac_nids = alc883_dac_nids,
9813                 .dig_out_nid = ALC883_DIGOUT_NID,
9814                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9815                 .channel_mode = alc883_3ST_2ch_modes,
9816                 .input_mux = &alc883_capture_source,
9817                 .unsol_event = alc_automute_amp_unsol_event,
9818                 .setup = alc883_medion_md2_setup,
9819                 .init_hook = alc_automute_amp,
9820         },
9821         [ALC883_LAPTOP_EAPD] = {
9822                 .mixers = { alc883_base_mixer },
9823                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
9824                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9825                 .dac_nids = alc883_dac_nids,
9826                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9827                 .channel_mode = alc883_3ST_2ch_modes,
9828                 .input_mux = &alc883_capture_source,
9829         },
9830         [ALC883_CLEVO_M540R] = {
9831                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9832                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
9833                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9834                 .dac_nids = alc883_dac_nids,
9835                 .dig_out_nid = ALC883_DIGOUT_NID,
9836                 .dig_in_nid = ALC883_DIGIN_NID,
9837                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
9838                 .channel_mode = alc883_3ST_6ch_clevo_modes,
9839                 .need_dac_fix = 1,
9840                 .input_mux = &alc883_capture_source,
9841                 /* This machine has the hardware HP auto-muting, thus
9842                  * we need no software mute via unsol event
9843                  */
9844         },
9845         [ALC883_CLEVO_M720] = {
9846                 .mixers = { alc883_clevo_m720_mixer },
9847                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
9848                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9849                 .dac_nids = alc883_dac_nids,
9850                 .dig_out_nid = ALC883_DIGOUT_NID,
9851                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9852                 .channel_mode = alc883_3ST_2ch_modes,
9853                 .input_mux = &alc883_capture_source,
9854                 .unsol_event = alc883_clevo_m720_unsol_event,
9855                 .setup = alc883_clevo_m720_setup,
9856                 .init_hook = alc883_clevo_m720_init_hook,
9857         },
9858         [ALC883_LENOVO_101E_2ch] = {
9859                 .mixers = { alc883_lenovo_101e_2ch_mixer},
9860                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
9861                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9862                 .dac_nids = alc883_dac_nids,
9863                 .adc_nids = alc883_adc_nids_alt,
9864                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9865                 .capsrc_nids = alc883_capsrc_nids,
9866                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9867                 .channel_mode = alc883_3ST_2ch_modes,
9868                 .input_mux = &alc883_lenovo_101e_capture_source,
9869                 .unsol_event = alc883_lenovo_101e_unsol_event,
9870                 .init_hook = alc883_lenovo_101e_all_automute,
9871         },
9872         [ALC883_LENOVO_NB0763] = {
9873                 .mixers = { alc883_lenovo_nb0763_mixer },
9874                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
9875                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9876                 .dac_nids = alc883_dac_nids,
9877                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9878                 .channel_mode = alc883_3ST_2ch_modes,
9879                 .need_dac_fix = 1,
9880                 .input_mux = &alc883_lenovo_nb0763_capture_source,
9881                 .unsol_event = alc_automute_amp_unsol_event,
9882                 .setup = alc883_medion_md2_setup,
9883                 .init_hook = alc_automute_amp,
9884         },
9885         [ALC888_LENOVO_MS7195_DIG] = {
9886                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9887                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
9888                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9889                 .dac_nids = alc883_dac_nids,
9890                 .dig_out_nid = ALC883_DIGOUT_NID,
9891                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9892                 .channel_mode = alc883_3ST_6ch_modes,
9893                 .need_dac_fix = 1,
9894                 .input_mux = &alc883_capture_source,
9895                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
9896                 .init_hook = alc888_lenovo_ms7195_front_automute,
9897         },
9898         [ALC883_HAIER_W66] = {
9899                 .mixers = { alc883_targa_2ch_mixer},
9900                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_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 = alc_automute_amp_unsol_event,
9908                 .setup = alc883_haier_w66_setup,
9909                 .init_hook = alc_automute_amp,
9910         },
9911         [ALC888_3ST_HP] = {
9912                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9913                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9914                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9915                 .dac_nids = alc883_dac_nids,
9916                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9917                 .channel_mode = alc888_3st_hp_modes,
9918                 .need_dac_fix = 1,
9919                 .input_mux = &alc883_capture_source,
9920                 .unsol_event = alc_automute_amp_unsol_event,
9921                 .setup = alc888_3st_hp_setup,
9922                 .init_hook = alc_automute_amp,
9923         },
9924         [ALC888_6ST_DELL] = {
9925                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9926                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9927                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9928                 .dac_nids = alc883_dac_nids,
9929                 .dig_out_nid = ALC883_DIGOUT_NID,
9930                 .dig_in_nid = ALC883_DIGIN_NID,
9931                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9932                 .channel_mode = alc883_sixstack_modes,
9933                 .input_mux = &alc883_capture_source,
9934                 .unsol_event = alc_automute_amp_unsol_event,
9935                 .setup = alc888_6st_dell_setup,
9936                 .init_hook = alc_automute_amp,
9937         },
9938         [ALC883_MITAC] = {
9939                 .mixers = { alc883_mitac_mixer },
9940                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9941                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9942                 .dac_nids = alc883_dac_nids,
9943                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9944                 .channel_mode = alc883_3ST_2ch_modes,
9945                 .input_mux = &alc883_capture_source,
9946                 .unsol_event = alc_automute_amp_unsol_event,
9947                 .setup = alc883_mitac_setup,
9948                 .init_hook = alc_automute_amp,
9949         },
9950         [ALC883_FUJITSU_PI2515] = {
9951                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9952                 .init_verbs = { alc883_init_verbs,
9953                                 alc883_2ch_fujitsu_pi2515_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_fujitsu_pi2515_capture_source,
9960                 .unsol_event = alc_automute_amp_unsol_event,
9961                 .setup = alc883_2ch_fujitsu_pi2515_setup,
9962                 .init_hook = alc_automute_amp,
9963         },
9964         [ALC888_FUJITSU_XA3530] = {
9965                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
9966                 .init_verbs = { alc883_init_verbs,
9967                         alc888_fujitsu_xa3530_verbs },
9968                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9969                 .dac_nids = alc883_dac_nids,
9970                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9971                 .adc_nids = alc883_adc_nids_rev,
9972                 .capsrc_nids = alc883_capsrc_nids_rev,
9973                 .dig_out_nid = ALC883_DIGOUT_NID,
9974                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9975                 .channel_mode = alc888_4ST_8ch_intel_modes,
9976                 .num_mux_defs =
9977                         ARRAY_SIZE(alc888_2_capture_sources),
9978                 .input_mux = alc888_2_capture_sources,
9979                 .unsol_event = alc_automute_amp_unsol_event,
9980                 .setup = alc888_fujitsu_xa3530_setup,
9981                 .init_hook = alc_automute_amp,
9982         },
9983         [ALC888_LENOVO_SKY] = {
9984                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9985                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9986                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9987                 .dac_nids = alc883_dac_nids,
9988                 .dig_out_nid = ALC883_DIGOUT_NID,
9989                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9990                 .channel_mode = alc883_sixstack_modes,
9991                 .need_dac_fix = 1,
9992                 .input_mux = &alc883_lenovo_sky_capture_source,
9993                 .unsol_event = alc_automute_amp_unsol_event,
9994                 .setup = alc888_lenovo_sky_setup,
9995                 .init_hook = alc_automute_amp,
9996         },
9997         [ALC888_ASUS_M90V] = {
9998                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9999                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10000                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10001                 .dac_nids = alc883_dac_nids,
10002                 .dig_out_nid = ALC883_DIGOUT_NID,
10003                 .dig_in_nid = ALC883_DIGIN_NID,
10004                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10005                 .channel_mode = alc883_3ST_6ch_modes,
10006                 .need_dac_fix = 1,
10007                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10008                 .unsol_event = alc_sku_unsol_event,
10009                 .setup = alc883_mode2_setup,
10010                 .init_hook = alc_inithook,
10011         },
10012         [ALC888_ASUS_EEE1601] = {
10013                 .mixers = { alc883_asus_eee1601_mixer },
10014                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
10015                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10016                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10017                 .dac_nids = alc883_dac_nids,
10018                 .dig_out_nid = ALC883_DIGOUT_NID,
10019                 .dig_in_nid = ALC883_DIGIN_NID,
10020                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10021                 .channel_mode = alc883_3ST_2ch_modes,
10022                 .need_dac_fix = 1,
10023                 .input_mux = &alc883_asus_eee1601_capture_source,
10024                 .unsol_event = alc_sku_unsol_event,
10025                 .init_hook = alc883_eee1601_inithook,
10026         },
10027         [ALC1200_ASUS_P5Q] = {
10028                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10029                 .init_verbs = { alc883_init_verbs },
10030                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10031                 .dac_nids = alc883_dac_nids,
10032                 .dig_out_nid = ALC1200_DIGOUT_NID,
10033                 .dig_in_nid = ALC883_DIGIN_NID,
10034                 .slave_dig_outs = alc1200_slave_dig_outs,
10035                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10036                 .channel_mode = alc883_sixstack_modes,
10037                 .input_mux = &alc883_capture_source,
10038         },
10039         [ALC889A_MB31] = {
10040                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10041                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10042                         alc880_gpio1_init_verbs },
10043                 .adc_nids = alc883_adc_nids,
10044                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10045                 .capsrc_nids = alc883_capsrc_nids,
10046                 .dac_nids = alc883_dac_nids,
10047                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10048                 .channel_mode = alc889A_mb31_6ch_modes,
10049                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10050                 .input_mux = &alc889A_mb31_capture_source,
10051                 .dig_out_nid = ALC883_DIGOUT_NID,
10052                 .unsol_event = alc889A_mb31_unsol_event,
10053                 .init_hook = alc889A_mb31_automute,
10054         },
10055         [ALC883_SONY_VAIO_TT] = {
10056                 .mixers = { alc883_vaiott_mixer },
10057                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10058                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10059                 .dac_nids = alc883_dac_nids,
10060                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10061                 .channel_mode = alc883_3ST_2ch_modes,
10062                 .input_mux = &alc883_capture_source,
10063                 .unsol_event = alc_automute_amp_unsol_event,
10064                 .setup = alc883_vaiott_setup,
10065                 .init_hook = alc_automute_amp,
10066         },
10067 };
10068
10069
10070 /*
10071  * Pin config fixes
10072  */
10073 enum {
10074         PINFIX_ABIT_AW9D_MAX
10075 };
10076
10077 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
10078         { 0x15, 0x01080104 }, /* side */
10079         { 0x16, 0x01011012 }, /* rear */
10080         { 0x17, 0x01016011 }, /* clfe */
10081         { }
10082 };
10083
10084 static const struct alc_fixup alc882_fixups[] = {
10085         [PINFIX_ABIT_AW9D_MAX] = {
10086                 .pins = alc882_abit_aw9d_pinfix
10087         },
10088 };
10089
10090 static struct snd_pci_quirk alc882_fixup_tbl[] = {
10091         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
10092         {}
10093 };
10094
10095 /*
10096  * BIOS auto configuration
10097  */
10098 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
10099                                                 const struct auto_pin_cfg *cfg)
10100 {
10101         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
10102 }
10103
10104 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
10105                                               hda_nid_t nid, int pin_type,
10106                                               int dac_idx)
10107 {
10108         /* set as output */
10109         struct alc_spec *spec = codec->spec;
10110         int idx;
10111
10112         alc_set_pin_output(codec, nid, pin_type);
10113         if (dac_idx >= spec->multiout.num_dacs)
10114                 return;
10115         if (spec->multiout.dac_nids[dac_idx] == 0x25)
10116                 idx = 4;
10117         else
10118                 idx = spec->multiout.dac_nids[dac_idx] - 2;
10119         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
10120
10121 }
10122
10123 static void alc882_auto_init_multi_out(struct hda_codec *codec)
10124 {
10125         struct alc_spec *spec = codec->spec;
10126         int i;
10127
10128         for (i = 0; i <= HDA_SIDE; i++) {
10129                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
10130                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
10131                 if (nid)
10132                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
10133                                                           i);
10134         }
10135 }
10136
10137 static void alc882_auto_init_hp_out(struct hda_codec *codec)
10138 {
10139         struct alc_spec *spec = codec->spec;
10140         hda_nid_t pin;
10141
10142         pin = spec->autocfg.hp_pins[0];
10143         if (pin) /* connect to front */
10144                 /* use dac 0 */
10145                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
10146         pin = spec->autocfg.speaker_pins[0];
10147         if (pin)
10148                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
10149 }
10150
10151 static void alc882_auto_init_analog_input(struct hda_codec *codec)
10152 {
10153         struct alc_spec *spec = codec->spec;
10154         int i;
10155
10156         for (i = 0; i < AUTO_PIN_LAST; i++) {
10157                 hda_nid_t nid = spec->autocfg.input_pins[i];
10158                 if (!nid)
10159                         continue;
10160                 alc_set_input_pin(codec, nid, i);
10161                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
10162                         snd_hda_codec_write(codec, nid, 0,
10163                                             AC_VERB_SET_AMP_GAIN_MUTE,
10164                                             AMP_OUT_MUTE);
10165         }
10166 }
10167
10168 static void alc882_auto_init_input_src(struct hda_codec *codec)
10169 {
10170         struct alc_spec *spec = codec->spec;
10171         int c;
10172
10173         for (c = 0; c < spec->num_adc_nids; c++) {
10174                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
10175                 hda_nid_t nid = spec->capsrc_nids[c];
10176                 unsigned int mux_idx;
10177                 const struct hda_input_mux *imux;
10178                 int conns, mute, idx, item;
10179
10180                 conns = snd_hda_get_connections(codec, nid, conn_list,
10181                                                 ARRAY_SIZE(conn_list));
10182                 if (conns < 0)
10183                         continue;
10184                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
10185                 imux = &spec->input_mux[mux_idx];
10186                 if (!imux->num_items && mux_idx > 0)
10187                         imux = &spec->input_mux[0];
10188                 for (idx = 0; idx < conns; idx++) {
10189                         /* if the current connection is the selected one,
10190                          * unmute it as default - otherwise mute it
10191                          */
10192                         mute = AMP_IN_MUTE(idx);
10193                         for (item = 0; item < imux->num_items; item++) {
10194                                 if (imux->items[item].index == idx) {
10195                                         if (spec->cur_mux[c] == item)
10196                                                 mute = AMP_IN_UNMUTE(idx);
10197                                         break;
10198                                 }
10199                         }
10200                         /* check if we have a selector or mixer
10201                          * we could check for the widget type instead, but
10202                          * just check for Amp-In presence (in case of mixer
10203                          * without amp-in there is something wrong, this
10204                          * function shouldn't be used or capsrc nid is wrong)
10205                          */
10206                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
10207                                 snd_hda_codec_write(codec, nid, 0,
10208                                                     AC_VERB_SET_AMP_GAIN_MUTE,
10209                                                     mute);
10210                         else if (mute != AMP_IN_MUTE(idx))
10211                                 snd_hda_codec_write(codec, nid, 0,
10212                                                     AC_VERB_SET_CONNECT_SEL,
10213                                                     idx);
10214                 }
10215         }
10216 }
10217
10218 /* add mic boosts if needed */
10219 static int alc_auto_add_mic_boost(struct hda_codec *codec)
10220 {
10221         struct alc_spec *spec = codec->spec;
10222         int err;
10223         hda_nid_t nid;
10224
10225         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
10226         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
10227                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10228                                   "Mic Boost",
10229                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10230                 if (err < 0)
10231                         return err;
10232         }
10233         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
10234         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
10235                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10236                                   "Front Mic Boost",
10237                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10238                 if (err < 0)
10239                         return err;
10240         }
10241         return 0;
10242 }
10243
10244 /* almost identical with ALC880 parser... */
10245 static int alc882_parse_auto_config(struct hda_codec *codec)
10246 {
10247         struct alc_spec *spec = codec->spec;
10248         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10249         int i, err;
10250
10251         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10252                                            alc882_ignore);
10253         if (err < 0)
10254                 return err;
10255         if (!spec->autocfg.line_outs)
10256                 return 0; /* can't find valid BIOS pin config */
10257
10258         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10259         if (err < 0)
10260                 return err;
10261         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10262         if (err < 0)
10263                 return err;
10264         err = alc880_auto_create_extra_out(spec,
10265                                            spec->autocfg.speaker_pins[0],
10266                                            "Speaker");
10267         if (err < 0)
10268                 return err;
10269         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10270                                            "Headphone");
10271         if (err < 0)
10272                 return err;
10273         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10274         if (err < 0)
10275                 return err;
10276
10277         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10278
10279         /* check multiple SPDIF-out (for recent codecs) */
10280         for (i = 0; i < spec->autocfg.dig_outs; i++) {
10281                 hda_nid_t dig_nid;
10282                 err = snd_hda_get_connections(codec,
10283                                               spec->autocfg.dig_out_pins[i],
10284                                               &dig_nid, 1);
10285                 if (err < 0)
10286                         continue;
10287                 if (!i)
10288                         spec->multiout.dig_out_nid = dig_nid;
10289                 else {
10290                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
10291                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
10292                                 break;
10293                         spec->slave_dig_outs[i - 1] = dig_nid;
10294                 }
10295         }
10296         if (spec->autocfg.dig_in_pin)
10297                 spec->dig_in_nid = ALC880_DIGIN_NID;
10298
10299         if (spec->kctls.list)
10300                 add_mixer(spec, spec->kctls.list);
10301
10302         add_verb(spec, alc883_auto_init_verbs);
10303         /* if ADC 0x07 is available, initialize it, too */
10304         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10305                 add_verb(spec, alc882_adc1_init_verbs);
10306
10307         spec->num_mux_defs = 1;
10308         spec->input_mux = &spec->private_imux[0];
10309
10310         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
10311
10312         err = alc_auto_add_mic_boost(codec);
10313         if (err < 0)
10314                 return err;
10315
10316         return 1; /* config found */
10317 }
10318
10319 /* additional initialization for auto-configuration model */
10320 static void alc882_auto_init(struct hda_codec *codec)
10321 {
10322         struct alc_spec *spec = codec->spec;
10323         alc882_auto_init_multi_out(codec);
10324         alc882_auto_init_hp_out(codec);
10325         alc882_auto_init_analog_input(codec);
10326         alc882_auto_init_input_src(codec);
10327         if (spec->unsol_event)
10328                 alc_inithook(codec);
10329 }
10330
10331 static int patch_alc882(struct hda_codec *codec)
10332 {
10333         struct alc_spec *spec;
10334         int err, board_config;
10335
10336         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10337         if (spec == NULL)
10338                 return -ENOMEM;
10339
10340         codec->spec = spec;
10341
10342         switch (codec->vendor_id) {
10343         case 0x10ec0882:
10344         case 0x10ec0885:
10345                 break;
10346         default:
10347                 /* ALC883 and variants */
10348                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10349                 break;
10350         }
10351
10352         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10353                                                   alc882_models,
10354                                                   alc882_cfg_tbl);
10355
10356         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10357                 board_config = snd_hda_check_board_codec_sid_config(codec,
10358                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10359
10360         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10361                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10362                        codec->chip_name);
10363                 board_config = ALC882_AUTO;
10364         }
10365
10366         alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups);
10367
10368         if (board_config == ALC882_AUTO) {
10369                 /* automatic parse from the BIOS config */
10370                 err = alc882_parse_auto_config(codec);
10371                 if (err < 0) {
10372                         alc_free(codec);
10373                         return err;
10374                 } else if (!err) {
10375                         printk(KERN_INFO
10376                                "hda_codec: Cannot set up configuration "
10377                                "from BIOS.  Using base mode...\n");
10378                         board_config = ALC882_3ST_DIG;
10379                 }
10380         }
10381
10382         err = snd_hda_attach_beep_device(codec, 0x1);
10383         if (err < 0) {
10384                 alc_free(codec);
10385                 return err;
10386         }
10387
10388         if (board_config != ALC882_AUTO)
10389                 setup_preset(codec, &alc882_presets[board_config]);
10390
10391         spec->stream_analog_playback = &alc882_pcm_analog_playback;
10392         spec->stream_analog_capture = &alc882_pcm_analog_capture;
10393         /* FIXME: setup DAC5 */
10394         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
10395         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
10396
10397         spec->stream_digital_playback = &alc882_pcm_digital_playback;
10398         spec->stream_digital_capture = &alc882_pcm_digital_capture;
10399
10400         if (codec->vendor_id == 0x10ec0888)
10401                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
10402
10403         if (!spec->adc_nids && spec->input_mux) {
10404                 int i, j;
10405                 spec->num_adc_nids = 0;
10406                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
10407                         const struct hda_input_mux *imux = spec->input_mux;
10408                         hda_nid_t cap;
10409                         hda_nid_t items[16];
10410                         hda_nid_t nid = alc882_adc_nids[i];
10411                         unsigned int wcap = get_wcaps(codec, nid);
10412                         /* get type */
10413                         wcap = get_wcaps_type(wcap);
10414                         if (wcap != AC_WID_AUD_IN)
10415                                 continue;
10416                         spec->private_adc_nids[spec->num_adc_nids] = nid;
10417                         err = snd_hda_get_connections(codec, nid, &cap, 1);
10418                         if (err < 0)
10419                                 continue;
10420                         err = snd_hda_get_connections(codec, cap, items,
10421                                                       ARRAY_SIZE(items));
10422                         if (err < 0)
10423                                 continue;
10424                         for (j = 0; j < imux->num_items; j++)
10425                                 if (imux->items[j].index >= err)
10426                                         break;
10427                         if (j < imux->num_items)
10428                                 continue;
10429                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
10430                         spec->num_adc_nids++;
10431                 }
10432                 spec->adc_nids = spec->private_adc_nids;
10433                 spec->capsrc_nids = spec->private_capsrc_nids;
10434         }
10435
10436         set_capture_mixer(codec);
10437         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
10438
10439         spec->vmaster_nid = 0x0c;
10440
10441         codec->patch_ops = alc_patch_ops;
10442         if (board_config == ALC882_AUTO)
10443                 spec->init_hook = alc882_auto_init;
10444 #ifdef CONFIG_SND_HDA_POWER_SAVE
10445         if (!spec->loopback.amplist)
10446                 spec->loopback.amplist = alc882_loopbacks;
10447 #endif
10448
10449         return 0;
10450 }
10451
10452
10453 /*
10454  * ALC262 support
10455  */
10456
10457 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
10458 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
10459
10460 #define alc262_dac_nids         alc260_dac_nids
10461 #define alc262_adc_nids         alc882_adc_nids
10462 #define alc262_adc_nids_alt     alc882_adc_nids_alt
10463 #define alc262_capsrc_nids      alc882_capsrc_nids
10464 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
10465
10466 #define alc262_modes            alc260_modes
10467 #define alc262_capture_source   alc882_capture_source
10468
10469 static hda_nid_t alc262_dmic_adc_nids[1] = {
10470         /* ADC0 */
10471         0x09
10472 };
10473
10474 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
10475
10476 static struct snd_kcontrol_new alc262_base_mixer[] = {
10477         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10478         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10479         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10480         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10481         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10482         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10483         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10484         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10485         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10486         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10487         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10488         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10489         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
10490         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10491         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
10492         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
10493         { } /* end */
10494 };
10495
10496 /* update HP, line and mono-out pins according to the master switch */
10497 static void alc262_hp_master_update(struct hda_codec *codec)
10498 {
10499         struct alc_spec *spec = codec->spec;
10500         int val = spec->master_sw;
10501
10502         /* HP & line-out */
10503         snd_hda_codec_write_cache(codec, 0x1b, 0,
10504                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10505                                   val ? PIN_HP : 0);
10506         snd_hda_codec_write_cache(codec, 0x15, 0,
10507                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10508                                   val ? PIN_HP : 0);
10509         /* mono (speaker) depending on the HP jack sense */
10510         val = val && !spec->jack_present;
10511         snd_hda_codec_write_cache(codec, 0x16, 0,
10512                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10513                                   val ? PIN_OUT : 0);
10514 }
10515
10516 static void alc262_hp_bpc_automute(struct hda_codec *codec)
10517 {
10518         struct alc_spec *spec = codec->spec;
10519
10520         spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
10521         alc262_hp_master_update(codec);
10522 }
10523
10524 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
10525 {
10526         if ((res >> 26) != ALC880_HP_EVENT)
10527                 return;
10528         alc262_hp_bpc_automute(codec);
10529 }
10530
10531 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
10532 {
10533         struct alc_spec *spec = codec->spec;
10534
10535         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
10536         alc262_hp_master_update(codec);
10537 }
10538
10539 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
10540                                            unsigned int res)
10541 {
10542         if ((res >> 26) != ALC880_HP_EVENT)
10543                 return;
10544         alc262_hp_wildwest_automute(codec);
10545 }
10546
10547 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
10548
10549 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
10550                                    struct snd_ctl_elem_value *ucontrol)
10551 {
10552         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10553         struct alc_spec *spec = codec->spec;
10554         int val = !!*ucontrol->value.integer.value;
10555
10556         if (val == spec->master_sw)
10557                 return 0;
10558         spec->master_sw = val;
10559         alc262_hp_master_update(codec);
10560         return 1;
10561 }
10562
10563 #define ALC262_HP_MASTER_SWITCH                                 \
10564         {                                                       \
10565                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10566                 .name = "Master Playback Switch",               \
10567                 .info = snd_ctl_boolean_mono_info,              \
10568                 .get = alc262_hp_master_sw_get,                 \
10569                 .put = alc262_hp_master_sw_put,                 \
10570         }, \
10571         {                                                       \
10572                 .iface = NID_MAPPING,                           \
10573                 .name = "Master Playback Switch",               \
10574                 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
10575         }
10576
10577
10578 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
10579         ALC262_HP_MASTER_SWITCH,
10580         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10581         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10582         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10583         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10584                               HDA_OUTPUT),
10585         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10586                             HDA_OUTPUT),
10587         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10588         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10589         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10590         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10591         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10592         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10593         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10594         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10595         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10596         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10597         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
10598         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
10599         { } /* end */
10600 };
10601
10602 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
10603         ALC262_HP_MASTER_SWITCH,
10604         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10605         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10606         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10607         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10608         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10609                               HDA_OUTPUT),
10610         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10611                             HDA_OUTPUT),
10612         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
10613         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
10614         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
10615         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10616         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10617         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10618         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10619         { } /* end */
10620 };
10621
10622 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
10623         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10624         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10625         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
10626         { } /* end */
10627 };
10628
10629 /* mute/unmute internal speaker according to the hp jack and mute state */
10630 static void alc262_hp_t5735_setup(struct hda_codec *codec)
10631 {
10632         struct alc_spec *spec = codec->spec;
10633
10634         spec->autocfg.hp_pins[0] = 0x15;
10635         spec->autocfg.speaker_pins[0] = 0x14;
10636 }
10637
10638 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
10639         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10640         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10641         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10642         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10643         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10644         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10645         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10646         { } /* end */
10647 };
10648
10649 static struct hda_verb alc262_hp_t5735_verbs[] = {
10650         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10651         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10652
10653         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10654         { }
10655 };
10656
10657 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
10658         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10659         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10660         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
10661         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
10662         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10663         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10664         { } /* end */
10665 };
10666
10667 static struct hda_verb alc262_hp_rp5700_verbs[] = {
10668         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10669         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10670         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10671         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10672         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10673         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10674         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10675         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10676         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10677         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10678         {}
10679 };
10680
10681 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
10682         .num_items = 1,
10683         .items = {
10684                 { "Line", 0x1 },
10685         },
10686 };
10687
10688 /* bind hp and internal speaker mute (with plug check) as master switch */
10689 static void alc262_hippo_master_update(struct hda_codec *codec)
10690 {
10691         struct alc_spec *spec = codec->spec;
10692         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10693         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
10694         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
10695         unsigned int mute;
10696
10697         /* HP */
10698         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
10699         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
10700                                  HDA_AMP_MUTE, mute);
10701         /* mute internal speaker per jack sense */
10702         if (spec->jack_present)
10703                 mute = HDA_AMP_MUTE;
10704         if (line_nid)
10705                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
10706                                          HDA_AMP_MUTE, mute);
10707         if (speaker_nid && speaker_nid != line_nid)
10708                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
10709                                          HDA_AMP_MUTE, mute);
10710 }
10711
10712 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
10713
10714 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
10715                                       struct snd_ctl_elem_value *ucontrol)
10716 {
10717         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10718         struct alc_spec *spec = codec->spec;
10719         int val = !!*ucontrol->value.integer.value;
10720
10721         if (val == spec->master_sw)
10722                 return 0;
10723         spec->master_sw = val;
10724         alc262_hippo_master_update(codec);
10725         return 1;
10726 }
10727
10728 #define ALC262_HIPPO_MASTER_SWITCH                              \
10729         {                                                       \
10730                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10731                 .name = "Master Playback Switch",               \
10732                 .info = snd_ctl_boolean_mono_info,              \
10733                 .get = alc262_hippo_master_sw_get,              \
10734                 .put = alc262_hippo_master_sw_put,              \
10735         },                                                      \
10736         {                                                       \
10737                 .iface = NID_MAPPING,                           \
10738                 .name = "Master Playback Switch",               \
10739                 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
10740                              (SUBDEV_SPEAKER(0) << 16), \
10741         }
10742
10743 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
10744         ALC262_HIPPO_MASTER_SWITCH,
10745         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10746         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10747         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10748         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10749         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10750         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10751         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10752         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10753         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10754         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10755         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10756         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10757         { } /* end */
10758 };
10759
10760 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
10761         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10762         ALC262_HIPPO_MASTER_SWITCH,
10763         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10764         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10765         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10766         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10767         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10768         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10769         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10770         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10771         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10772         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10773         { } /* end */
10774 };
10775
10776 /* mute/unmute internal speaker according to the hp jack and mute state */
10777 static void alc262_hippo_automute(struct hda_codec *codec)
10778 {
10779         struct alc_spec *spec = codec->spec;
10780         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10781
10782         spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
10783         alc262_hippo_master_update(codec);
10784 }
10785
10786 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
10787 {
10788         if ((res >> 26) != ALC880_HP_EVENT)
10789                 return;
10790         alc262_hippo_automute(codec);
10791 }
10792
10793 static void alc262_hippo_setup(struct hda_codec *codec)
10794 {
10795         struct alc_spec *spec = codec->spec;
10796
10797         spec->autocfg.hp_pins[0] = 0x15;
10798         spec->autocfg.speaker_pins[0] = 0x14;
10799 }
10800
10801 static void alc262_hippo1_setup(struct hda_codec *codec)
10802 {
10803         struct alc_spec *spec = codec->spec;
10804
10805         spec->autocfg.hp_pins[0] = 0x1b;
10806         spec->autocfg.speaker_pins[0] = 0x14;
10807 }
10808
10809
10810 static struct snd_kcontrol_new alc262_sony_mixer[] = {
10811         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10812         ALC262_HIPPO_MASTER_SWITCH,
10813         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10814         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10815         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10816         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10817         { } /* end */
10818 };
10819
10820 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
10821         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10822         ALC262_HIPPO_MASTER_SWITCH,
10823         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10824         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10825         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10826         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10827         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10828         { } /* end */
10829 };
10830
10831 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
10832         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10833         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10834         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
10835         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
10836         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10837         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10838         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10839         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10840         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10841         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10842         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10843         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10844         { } /* end */
10845 };
10846
10847 static struct hda_verb alc262_tyan_verbs[] = {
10848         /* Headphone automute */
10849         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10850         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10851         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10852
10853         /* P11 AUX_IN, white 4-pin connector */
10854         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10855         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
10856         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
10857         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
10858
10859         {}
10860 };
10861
10862 /* unsolicited event for HP jack sensing */
10863 static void alc262_tyan_setup(struct hda_codec *codec)
10864 {
10865         struct alc_spec *spec = codec->spec;
10866
10867         spec->autocfg.hp_pins[0] = 0x1b;
10868         spec->autocfg.speaker_pins[0] = 0x15;
10869 }
10870
10871
10872 #define alc262_capture_mixer            alc882_capture_mixer
10873 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
10874
10875 /*
10876  * generic initialization of ADC, input mixers and output mixers
10877  */
10878 static struct hda_verb alc262_init_verbs[] = {
10879         /*
10880          * Unmute ADC0-2 and set the default input to mic-in
10881          */
10882         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10883         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10884         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10885         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10886         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10887         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10888
10889         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10890          * mixer widget
10891          * Note: PASD motherboards uses the Line In 2 as the input for
10892          * front panel mic (mic 2)
10893          */
10894         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10895         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10896         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10897         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10898         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10899         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10900
10901         /*
10902          * Set up output mixers (0x0c - 0x0e)
10903          */
10904         /* set vol=0 to output mixers */
10905         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10906         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10907         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10908         /* set up input amps for analog loopback */
10909         /* Amp Indices: DAC = 0, mixer = 1 */
10910         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10911         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10912         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10913         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10914         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10915         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10916
10917         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10918         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10919         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10920         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10921         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10922         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10923
10924         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10925         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10926         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10927         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10928         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10929
10930         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10931         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10932
10933         /* FIXME: use matrix-type input source selection */
10934         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10935         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10936         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10937         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10938         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10939         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10940         /* Input mixer2 */
10941         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10942         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10943         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10944         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10945         /* Input mixer3 */
10946         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10947         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10948         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10949         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10950
10951         { }
10952 };
10953
10954 static struct hda_verb alc262_eapd_verbs[] = {
10955         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10956         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10957         { }
10958 };
10959
10960 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
10961         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10962         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10963         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10964
10965         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10966         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10967         {}
10968 };
10969
10970 static struct hda_verb alc262_sony_unsol_verbs[] = {
10971         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10972         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10973         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
10974
10975         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10976         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10977         {}
10978 };
10979
10980 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
10981         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10982         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10983         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10984         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10985         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10986         { } /* end */
10987 };
10988
10989 static struct hda_verb alc262_toshiba_s06_verbs[] = {
10990         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10991         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10992         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10993         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10994         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
10995         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10996         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10997         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10998         {}
10999 };
11000
11001 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11002 {
11003         struct alc_spec *spec = codec->spec;
11004
11005         spec->autocfg.hp_pins[0] = 0x15;
11006         spec->autocfg.speaker_pins[0] = 0x14;
11007         spec->ext_mic.pin = 0x18;
11008         spec->ext_mic.mux_idx = 0;
11009         spec->int_mic.pin = 0x12;
11010         spec->int_mic.mux_idx = 9;
11011         spec->auto_mic = 1;
11012 }
11013
11014 /*
11015  * nec model
11016  *  0x15 = headphone
11017  *  0x16 = internal speaker
11018  *  0x18 = external mic
11019  */
11020
11021 static struct snd_kcontrol_new alc262_nec_mixer[] = {
11022         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11023         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11024
11025         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11026         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11027         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11028
11029         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11030         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11031         { } /* end */
11032 };
11033
11034 static struct hda_verb alc262_nec_verbs[] = {
11035         /* Unmute Speaker */
11036         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11037
11038         /* Headphone */
11039         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11040         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11041
11042         /* External mic to headphone */
11043         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11044         /* External mic to speaker */
11045         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11046         {}
11047 };
11048
11049 /*
11050  * fujitsu model
11051  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11052  *  0x1b = port replicator headphone out
11053  */
11054
11055 #define ALC_HP_EVENT    0x37
11056
11057 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11058         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11059         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11060         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11061         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11062         {}
11063 };
11064
11065 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11066         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11067         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11068         {}
11069 };
11070
11071 static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11072         /* Front Mic pin: input vref at 50% */
11073         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11074         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11075         {}
11076 };
11077
11078 static struct hda_input_mux alc262_fujitsu_capture_source = {
11079         .num_items = 3,
11080         .items = {
11081                 { "Mic", 0x0 },
11082                 { "Int Mic", 0x1 },
11083                 { "CD", 0x4 },
11084         },
11085 };
11086
11087 static struct hda_input_mux alc262_HP_capture_source = {
11088         .num_items = 5,
11089         .items = {
11090                 { "Mic", 0x0 },
11091                 { "Front Mic", 0x1 },
11092                 { "Line", 0x2 },
11093                 { "CD", 0x4 },
11094                 { "AUX IN", 0x6 },
11095         },
11096 };
11097
11098 static struct hda_input_mux alc262_HP_D7000_capture_source = {
11099         .num_items = 4,
11100         .items = {
11101                 { "Mic", 0x0 },
11102                 { "Front Mic", 0x2 },
11103                 { "Line", 0x1 },
11104                 { "CD", 0x4 },
11105         },
11106 };
11107
11108 /* mute/unmute internal speaker according to the hp jacks and mute state */
11109 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
11110 {
11111         struct alc_spec *spec = codec->spec;
11112         unsigned int mute;
11113
11114         if (force || !spec->sense_updated) {
11115                 spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
11116                                      snd_hda_jack_detect(codec, 0x1b);
11117                 spec->sense_updated = 1;
11118         }
11119         /* unmute internal speaker only if both HPs are unplugged and
11120          * master switch is on
11121          */
11122         if (spec->jack_present)
11123                 mute = HDA_AMP_MUTE;
11124         else
11125                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11126         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11127                                  HDA_AMP_MUTE, mute);
11128 }
11129
11130 /* unsolicited event for HP jack sensing */
11131 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
11132                                        unsigned int res)
11133 {
11134         if ((res >> 26) != ALC_HP_EVENT)
11135                 return;
11136         alc262_fujitsu_automute(codec, 1);
11137 }
11138
11139 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
11140 {
11141         alc262_fujitsu_automute(codec, 1);
11142 }
11143
11144 /* bind volumes of both NID 0x0c and 0x0d */
11145 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11146         .ops = &snd_hda_bind_vol,
11147         .values = {
11148                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11149                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11150                 0
11151         },
11152 };
11153
11154 /* mute/unmute internal speaker according to the hp jack and mute state */
11155 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
11156 {
11157         struct alc_spec *spec = codec->spec;
11158         unsigned int mute;
11159
11160         if (force || !spec->sense_updated) {
11161                 spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11162                 spec->sense_updated = 1;
11163         }
11164         if (spec->jack_present) {
11165                 /* mute internal speaker */
11166                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11167                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11168                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11169                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11170         } else {
11171                 /* unmute internal speaker if necessary */
11172                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
11173                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11174                                          HDA_AMP_MUTE, mute);
11175                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11176                                          HDA_AMP_MUTE, mute);
11177         }
11178 }
11179
11180 /* unsolicited event for HP jack sensing */
11181 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
11182                                        unsigned int res)
11183 {
11184         if ((res >> 26) != ALC_HP_EVENT)
11185                 return;
11186         alc262_lenovo_3000_automute(codec, 1);
11187 }
11188
11189 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
11190                                   int dir, int idx, long *valp)
11191 {
11192         int i, change = 0;
11193
11194         for (i = 0; i < 2; i++, valp++)
11195                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
11196                                                    HDA_AMP_MUTE,
11197                                                    *valp ? 0 : HDA_AMP_MUTE);
11198         return change;
11199 }
11200
11201 /* bind hp and internal speaker mute (with plug check) */
11202 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
11203                                          struct snd_ctl_elem_value *ucontrol)
11204 {
11205         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11206         long *valp = ucontrol->value.integer.value;
11207         int change;
11208
11209         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11210         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11211         if (change)
11212                 alc262_fujitsu_automute(codec, 0);
11213         return change;
11214 }
11215
11216 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
11217         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11218         {
11219                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11220                 .name = "Master Playback Switch",
11221                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11222                 .info = snd_hda_mixer_amp_switch_info,
11223                 .get = snd_hda_mixer_amp_switch_get,
11224                 .put = alc262_fujitsu_master_sw_put,
11225                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11226         },
11227         {
11228                 .iface = NID_MAPPING,
11229                 .name = "Master Playback Switch",
11230                 .private_value = 0x1b,
11231         },
11232         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11233         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11234         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11235         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11236         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11237         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11238         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11239         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11240         { } /* end */
11241 };
11242
11243 /* bind hp and internal speaker mute (with plug check) */
11244 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
11245                                          struct snd_ctl_elem_value *ucontrol)
11246 {
11247         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11248         long *valp = ucontrol->value.integer.value;
11249         int change;
11250
11251         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11252         if (change)
11253                 alc262_lenovo_3000_automute(codec, 0);
11254         return change;
11255 }
11256
11257 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
11258         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11259         {
11260                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11261                 .name = "Master Playback Switch",
11262                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11263                 .info = snd_hda_mixer_amp_switch_info,
11264                 .get = snd_hda_mixer_amp_switch_get,
11265                 .put = alc262_lenovo_3000_master_sw_put,
11266                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11267         },
11268         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11269         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11270         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11271         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11272         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11273         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11274         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11275         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11276         { } /* end */
11277 };
11278
11279 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11280         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11281         ALC262_HIPPO_MASTER_SWITCH,
11282         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11283         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11284         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11285         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11286         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11287         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11288         { } /* end */
11289 };
11290
11291 /* additional init verbs for Benq laptops */
11292 static struct hda_verb alc262_EAPD_verbs[] = {
11293         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11294         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11295         {}
11296 };
11297
11298 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11299         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11300         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11301
11302         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11303         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11304         {}
11305 };
11306
11307 /* Samsung Q1 Ultra Vista model setup */
11308 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11309         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11310         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11311         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11312         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11313         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
11314         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
11315         { } /* end */
11316 };
11317
11318 static struct hda_verb alc262_ultra_verbs[] = {
11319         /* output mixer */
11320         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11321         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11322         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11323         /* speaker */
11324         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11325         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11326         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11327         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11328         /* HP */
11329         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11330         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11331         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11332         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11333         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11334         /* internal mic */
11335         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11336         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11337         /* ADC, choose mic */
11338         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11339         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11340         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11341         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11342         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11343         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11344         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11345         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11346         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11347         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11348         {}
11349 };
11350
11351 /* mute/unmute internal speaker according to the hp jack and mute state */
11352 static void alc262_ultra_automute(struct hda_codec *codec)
11353 {
11354         struct alc_spec *spec = codec->spec;
11355         unsigned int mute;
11356
11357         mute = 0;
11358         /* auto-mute only when HP is used as HP */
11359         if (!spec->cur_mux[0]) {
11360                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11361                 if (spec->jack_present)
11362                         mute = HDA_AMP_MUTE;
11363         }
11364         /* mute/unmute internal speaker */
11365         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11366                                  HDA_AMP_MUTE, mute);
11367         /* mute/unmute HP */
11368         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11369                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
11370 }
11371
11372 /* unsolicited event for HP jack sensing */
11373 static void alc262_ultra_unsol_event(struct hda_codec *codec,
11374                                        unsigned int res)
11375 {
11376         if ((res >> 26) != ALC880_HP_EVENT)
11377                 return;
11378         alc262_ultra_automute(codec);
11379 }
11380
11381 static struct hda_input_mux alc262_ultra_capture_source = {
11382         .num_items = 2,
11383         .items = {
11384                 { "Mic", 0x1 },
11385                 { "Headphone", 0x7 },
11386         },
11387 };
11388
11389 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
11390                                      struct snd_ctl_elem_value *ucontrol)
11391 {
11392         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11393         struct alc_spec *spec = codec->spec;
11394         int ret;
11395
11396         ret = alc_mux_enum_put(kcontrol, ucontrol);
11397         if (!ret)
11398                 return 0;
11399         /* reprogram the HP pin as mic or HP according to the input source */
11400         snd_hda_codec_write_cache(codec, 0x15, 0,
11401                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11402                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
11403         alc262_ultra_automute(codec); /* mute/unmute HP */
11404         return ret;
11405 }
11406
11407 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
11408         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
11409         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
11410         {
11411                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11412                 .name = "Capture Source",
11413                 .info = alc_mux_enum_info,
11414                 .get = alc_mux_enum_get,
11415                 .put = alc262_ultra_mux_enum_put,
11416         },
11417         {
11418                 .iface = NID_MAPPING,
11419                 .name = "Capture Source",
11420                 .private_value = 0x15,
11421         },
11422         { } /* end */
11423 };
11424
11425 /* We use two mixers depending on the output pin; 0x16 is a mono output
11426  * and thus it's bound with a different mixer.
11427  * This function returns which mixer amp should be used.
11428  */
11429 static int alc262_check_volbit(hda_nid_t nid)
11430 {
11431         if (!nid)
11432                 return 0;
11433         else if (nid == 0x16)
11434                 return 2;
11435         else
11436                 return 1;
11437 }
11438
11439 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
11440                                   const char *pfx, int *vbits)
11441 {
11442         unsigned long val;
11443         int vbit;
11444
11445         vbit = alc262_check_volbit(nid);
11446         if (!vbit)
11447                 return 0;
11448         if (*vbits & vbit) /* a volume control for this mixer already there */
11449                 return 0;
11450         *vbits |= vbit;
11451         if (vbit == 2)
11452                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
11453         else
11454                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
11455         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, val);
11456 }
11457
11458 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
11459                                  const char *pfx)
11460 {
11461         unsigned long val;
11462
11463         if (!nid)
11464                 return 0;
11465         if (nid == 0x16)
11466                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
11467         else
11468                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
11469         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, val);
11470 }
11471
11472 /* add playback controls from the parsed DAC table */
11473 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
11474                                              const struct auto_pin_cfg *cfg)
11475 {
11476         const char *pfx;
11477         int vbits;
11478         int err;
11479
11480         spec->multiout.num_dacs = 1;    /* only use one dac */
11481         spec->multiout.dac_nids = spec->private_dac_nids;
11482         spec->multiout.dac_nids[0] = 2;
11483
11484         if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
11485                 pfx = "Master";
11486         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11487                 pfx = "Speaker";
11488         else
11489                 pfx = "Front";
11490         err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[0], pfx);
11491         if (err < 0)
11492                 return err;
11493         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[0], "Speaker");
11494         if (err < 0)
11495                 return err;
11496         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[0], "Headphone");
11497         if (err < 0)
11498                 return err;
11499
11500         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
11501                 alc262_check_volbit(cfg->speaker_pins[0]) |
11502                 alc262_check_volbit(cfg->hp_pins[0]);
11503         if (vbits == 1 || vbits == 2)
11504                 pfx = "Master"; /* only one mixer is used */
11505         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11506                 pfx = "Speaker";
11507         else
11508                 pfx = "Front";
11509         vbits = 0;
11510         err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[0], pfx, &vbits);
11511         if (err < 0)
11512                 return err;
11513         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[0], "Speaker",
11514                                      &vbits);
11515         if (err < 0)
11516                 return err;
11517         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[0], "Headphone",
11518                                      &vbits);
11519         if (err < 0)
11520                 return err;
11521         return 0;
11522 }
11523
11524 #define alc262_auto_create_input_ctls \
11525         alc882_auto_create_input_ctls
11526
11527 /*
11528  * generic initialization of ADC, input mixers and output mixers
11529  */
11530 static struct hda_verb alc262_volume_init_verbs[] = {
11531         /*
11532          * Unmute ADC0-2 and set the default input to mic-in
11533          */
11534         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11535         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11536         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11537         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11538         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11539         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11540
11541         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11542          * mixer widget
11543          * Note: PASD motherboards uses the Line In 2 as the input for
11544          * front panel mic (mic 2)
11545          */
11546         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11547         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11548         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11549         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11550         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11551         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11552
11553         /*
11554          * Set up output mixers (0x0c - 0x0f)
11555          */
11556         /* set vol=0 to output mixers */
11557         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11558         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11559         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11560
11561         /* set up input amps for analog loopback */
11562         /* Amp Indices: DAC = 0, mixer = 1 */
11563         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11564         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11565         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11566         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11567         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11568         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11569
11570         /* FIXME: use matrix-type input source selection */
11571         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11572         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11573         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11574         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11575         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11576         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11577         /* Input mixer2 */
11578         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11579         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11580         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11581         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11582         /* Input mixer3 */
11583         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11584         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11585         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11586         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11587
11588         { }
11589 };
11590
11591 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
11592         /*
11593          * Unmute ADC0-2 and set the default input to mic-in
11594          */
11595         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11596         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11597         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11598         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11599         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11600         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11601
11602         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11603          * mixer widget
11604          * Note: PASD motherboards uses the Line In 2 as the input for
11605          * front panel mic (mic 2)
11606          */
11607         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11608         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11609         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11610         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11611         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11612         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11613         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11614         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11615
11616         /*
11617          * Set up output mixers (0x0c - 0x0e)
11618          */
11619         /* set vol=0 to output mixers */
11620         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11621         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11622         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11623
11624         /* set up input amps for analog loopback */
11625         /* Amp Indices: DAC = 0, mixer = 1 */
11626         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11627         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11628         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11629         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11630         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11631         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11632
11633         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11634         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11635         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11636
11637         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11638         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11639
11640         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11641         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11642
11643         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11644         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11645         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11646         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11647         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11648
11649         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11650         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11651         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11652         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11653         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11654         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11655
11656
11657         /* FIXME: use matrix-type input source selection */
11658         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
11659         /* Input mixer1: only unmute Mic */
11660         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11661         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11662         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11663         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11664         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11665         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11666         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11667         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11668         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11669         /* Input mixer2 */
11670         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11671         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11672         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11673         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11674         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11675         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11676         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11677         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11678         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11679         /* Input mixer3 */
11680         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11681         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11682         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11683         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11684         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11685         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11686         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11687         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11688         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11689
11690         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11691
11692         { }
11693 };
11694
11695 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
11696         /*
11697          * Unmute ADC0-2 and set the default input to mic-in
11698          */
11699         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11700         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11701         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11702         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11703         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11704         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11705
11706         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11707          * mixer widget
11708          * Note: PASD motherboards uses the Line In 2 as the input for front
11709          * panel mic (mic 2)
11710          */
11711         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11712         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11713         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11714         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11715         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11716         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11717         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11718         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11719         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11720         /*
11721          * Set up output mixers (0x0c - 0x0e)
11722          */
11723         /* set vol=0 to output mixers */
11724         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11725         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11726         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11727
11728         /* set up input amps for analog loopback */
11729         /* Amp Indices: DAC = 0, mixer = 1 */
11730         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11731         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11732         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11733         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11734         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11735         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11736
11737
11738         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
11739         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
11740         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
11741         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
11742         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11743         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
11744         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
11745
11746         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11747         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11748
11749         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11750         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11751
11752         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
11753         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11754         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11755         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
11756         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11757         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11758
11759         /* FIXME: use matrix-type input source selection */
11760         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11761         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11762         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
11763         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
11764         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
11765         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
11766         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
11767         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
11768         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
11769         /* Input mixer2 */
11770         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11771         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11772         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11773         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11774         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11775         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11776         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11777         /* Input mixer3 */
11778         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11779         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11780         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11781         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11782         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11783         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11784         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11785
11786         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11787
11788         { }
11789 };
11790
11791 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
11792
11793         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
11794         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11795         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
11796
11797         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
11798         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11799         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11800         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11801
11802         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
11803         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11804         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11805         {}
11806 };
11807
11808
11809 #ifdef CONFIG_SND_HDA_POWER_SAVE
11810 #define alc262_loopbacks        alc880_loopbacks
11811 #endif
11812
11813 /* pcm configuration: identical with ALC880 */
11814 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
11815 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
11816 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
11817 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
11818
11819 /*
11820  * BIOS auto configuration
11821  */
11822 static int alc262_parse_auto_config(struct hda_codec *codec)
11823 {
11824         struct alc_spec *spec = codec->spec;
11825         int err;
11826         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
11827
11828         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11829                                            alc262_ignore);
11830         if (err < 0)
11831                 return err;
11832         if (!spec->autocfg.line_outs) {
11833                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11834                         spec->multiout.max_channels = 2;
11835                         spec->no_analog = 1;
11836                         goto dig_only;
11837                 }
11838                 return 0; /* can't find valid BIOS pin config */
11839         }
11840         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
11841         if (err < 0)
11842                 return err;
11843         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
11844         if (err < 0)
11845                 return err;
11846
11847         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11848
11849  dig_only:
11850         if (spec->autocfg.dig_outs) {
11851                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
11852                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11853         }
11854         if (spec->autocfg.dig_in_pin)
11855                 spec->dig_in_nid = ALC262_DIGIN_NID;
11856
11857         if (spec->kctls.list)
11858                 add_mixer(spec, spec->kctls.list);
11859
11860         add_verb(spec, alc262_volume_init_verbs);
11861         spec->num_mux_defs = 1;
11862         spec->input_mux = &spec->private_imux[0];
11863
11864         err = alc_auto_add_mic_boost(codec);
11865         if (err < 0)
11866                 return err;
11867
11868         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
11869
11870         return 1;
11871 }
11872
11873 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
11874 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
11875 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
11876 #define alc262_auto_init_input_src      alc882_auto_init_input_src
11877
11878
11879 /* init callback for auto-configuration model -- overriding the default init */
11880 static void alc262_auto_init(struct hda_codec *codec)
11881 {
11882         struct alc_spec *spec = codec->spec;
11883         alc262_auto_init_multi_out(codec);
11884         alc262_auto_init_hp_out(codec);
11885         alc262_auto_init_analog_input(codec);
11886         alc262_auto_init_input_src(codec);
11887         if (spec->unsol_event)
11888                 alc_inithook(codec);
11889 }
11890
11891 /*
11892  * configuration and preset
11893  */
11894 static const char *alc262_models[ALC262_MODEL_LAST] = {
11895         [ALC262_BASIC]          = "basic",
11896         [ALC262_HIPPO]          = "hippo",
11897         [ALC262_HIPPO_1]        = "hippo_1",
11898         [ALC262_FUJITSU]        = "fujitsu",
11899         [ALC262_HP_BPC]         = "hp-bpc",
11900         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
11901         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
11902         [ALC262_HP_RP5700]      = "hp-rp5700",
11903         [ALC262_BENQ_ED8]       = "benq",
11904         [ALC262_BENQ_T31]       = "benq-t31",
11905         [ALC262_SONY_ASSAMD]    = "sony-assamd",
11906         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
11907         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
11908         [ALC262_ULTRA]          = "ultra",
11909         [ALC262_LENOVO_3000]    = "lenovo-3000",
11910         [ALC262_NEC]            = "nec",
11911         [ALC262_TYAN]           = "tyan",
11912         [ALC262_AUTO]           = "auto",
11913 };
11914
11915 static struct snd_pci_quirk alc262_cfg_tbl[] = {
11916         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
11917         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
11918         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
11919                            ALC262_HP_BPC),
11920         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
11921                            ALC262_HP_BPC),
11922         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
11923                            ALC262_HP_BPC),
11924         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
11925         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
11926         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
11927         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
11928         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
11929         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
11930         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
11931         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
11932         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
11933         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
11934         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
11935         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
11936                       ALC262_HP_TC_T5735),
11937         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
11938         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11939         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
11940         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11941         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
11942         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
11943         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
11944         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
11945 #if 0 /* disable the quirk since model=auto works better in recent versions */
11946         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
11947                            ALC262_SONY_ASSAMD),
11948 #endif
11949         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
11950                       ALC262_TOSHIBA_RX1),
11951         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
11952         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
11953         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
11954         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
11955         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
11956                            ALC262_ULTRA),
11957         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
11958         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
11959         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
11960         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
11961         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
11962         {}
11963 };
11964
11965 static struct alc_config_preset alc262_presets[] = {
11966         [ALC262_BASIC] = {
11967                 .mixers = { alc262_base_mixer },
11968                 .init_verbs = { alc262_init_verbs },
11969                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11970                 .dac_nids = alc262_dac_nids,
11971                 .hp_nid = 0x03,
11972                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11973                 .channel_mode = alc262_modes,
11974                 .input_mux = &alc262_capture_source,
11975         },
11976         [ALC262_HIPPO] = {
11977                 .mixers = { alc262_hippo_mixer },
11978                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
11979                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11980                 .dac_nids = alc262_dac_nids,
11981                 .hp_nid = 0x03,
11982                 .dig_out_nid = ALC262_DIGOUT_NID,
11983                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11984                 .channel_mode = alc262_modes,
11985                 .input_mux = &alc262_capture_source,
11986                 .unsol_event = alc262_hippo_unsol_event,
11987                 .setup = alc262_hippo_setup,
11988                 .init_hook = alc262_hippo_automute,
11989         },
11990         [ALC262_HIPPO_1] = {
11991                 .mixers = { alc262_hippo1_mixer },
11992                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
11993                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11994                 .dac_nids = alc262_dac_nids,
11995                 .hp_nid = 0x02,
11996                 .dig_out_nid = ALC262_DIGOUT_NID,
11997                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11998                 .channel_mode = alc262_modes,
11999                 .input_mux = &alc262_capture_source,
12000                 .unsol_event = alc262_hippo_unsol_event,
12001                 .setup = alc262_hippo1_setup,
12002                 .init_hook = alc262_hippo_automute,
12003         },
12004         [ALC262_FUJITSU] = {
12005                 .mixers = { alc262_fujitsu_mixer },
12006                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12007                                 alc262_fujitsu_unsol_verbs },
12008                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12009                 .dac_nids = alc262_dac_nids,
12010                 .hp_nid = 0x03,
12011                 .dig_out_nid = ALC262_DIGOUT_NID,
12012                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12013                 .channel_mode = alc262_modes,
12014                 .input_mux = &alc262_fujitsu_capture_source,
12015                 .unsol_event = alc262_fujitsu_unsol_event,
12016                 .init_hook = alc262_fujitsu_init_hook,
12017         },
12018         [ALC262_HP_BPC] = {
12019                 .mixers = { alc262_HP_BPC_mixer },
12020                 .init_verbs = { alc262_HP_BPC_init_verbs },
12021                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12022                 .dac_nids = alc262_dac_nids,
12023                 .hp_nid = 0x03,
12024                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12025                 .channel_mode = alc262_modes,
12026                 .input_mux = &alc262_HP_capture_source,
12027                 .unsol_event = alc262_hp_bpc_unsol_event,
12028                 .init_hook = alc262_hp_bpc_automute,
12029         },
12030         [ALC262_HP_BPC_D7000_WF] = {
12031                 .mixers = { alc262_HP_BPC_WildWest_mixer },
12032                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12033                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12034                 .dac_nids = alc262_dac_nids,
12035                 .hp_nid = 0x03,
12036                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12037                 .channel_mode = alc262_modes,
12038                 .input_mux = &alc262_HP_D7000_capture_source,
12039                 .unsol_event = alc262_hp_wildwest_unsol_event,
12040                 .init_hook = alc262_hp_wildwest_automute,
12041         },
12042         [ALC262_HP_BPC_D7000_WL] = {
12043                 .mixers = { alc262_HP_BPC_WildWest_mixer,
12044                             alc262_HP_BPC_WildWest_option_mixer },
12045                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12046                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12047                 .dac_nids = alc262_dac_nids,
12048                 .hp_nid = 0x03,
12049                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12050                 .channel_mode = alc262_modes,
12051                 .input_mux = &alc262_HP_D7000_capture_source,
12052                 .unsol_event = alc262_hp_wildwest_unsol_event,
12053                 .init_hook = alc262_hp_wildwest_automute,
12054         },
12055         [ALC262_HP_TC_T5735] = {
12056                 .mixers = { alc262_hp_t5735_mixer },
12057                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12058                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12059                 .dac_nids = alc262_dac_nids,
12060                 .hp_nid = 0x03,
12061                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12062                 .channel_mode = alc262_modes,
12063                 .input_mux = &alc262_capture_source,
12064                 .unsol_event = alc_sku_unsol_event,
12065                 .setup = alc262_hp_t5735_setup,
12066                 .init_hook = alc_inithook,
12067         },
12068         [ALC262_HP_RP5700] = {
12069                 .mixers = { alc262_hp_rp5700_mixer },
12070                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12071                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12072                 .dac_nids = alc262_dac_nids,
12073                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12074                 .channel_mode = alc262_modes,
12075                 .input_mux = &alc262_hp_rp5700_capture_source,
12076         },
12077         [ALC262_BENQ_ED8] = {
12078                 .mixers = { alc262_base_mixer },
12079                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12080                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12081                 .dac_nids = alc262_dac_nids,
12082                 .hp_nid = 0x03,
12083                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12084                 .channel_mode = alc262_modes,
12085                 .input_mux = &alc262_capture_source,
12086         },
12087         [ALC262_SONY_ASSAMD] = {
12088                 .mixers = { alc262_sony_mixer },
12089                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12090                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12091                 .dac_nids = alc262_dac_nids,
12092                 .hp_nid = 0x02,
12093                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12094                 .channel_mode = alc262_modes,
12095                 .input_mux = &alc262_capture_source,
12096                 .unsol_event = alc262_hippo_unsol_event,
12097                 .setup = alc262_hippo_setup,
12098                 .init_hook = alc262_hippo_automute,
12099         },
12100         [ALC262_BENQ_T31] = {
12101                 .mixers = { alc262_benq_t31_mixer },
12102                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12103                                 alc_hp15_unsol_verbs },
12104                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12105                 .dac_nids = alc262_dac_nids,
12106                 .hp_nid = 0x03,
12107                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12108                 .channel_mode = alc262_modes,
12109                 .input_mux = &alc262_capture_source,
12110                 .unsol_event = alc262_hippo_unsol_event,
12111                 .setup = alc262_hippo_setup,
12112                 .init_hook = alc262_hippo_automute,
12113         },
12114         [ALC262_ULTRA] = {
12115                 .mixers = { alc262_ultra_mixer },
12116                 .cap_mixer = alc262_ultra_capture_mixer,
12117                 .init_verbs = { alc262_ultra_verbs },
12118                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12119                 .dac_nids = alc262_dac_nids,
12120                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12121                 .channel_mode = alc262_modes,
12122                 .input_mux = &alc262_ultra_capture_source,
12123                 .adc_nids = alc262_adc_nids, /* ADC0 */
12124                 .capsrc_nids = alc262_capsrc_nids,
12125                 .num_adc_nids = 1, /* single ADC */
12126                 .unsol_event = alc262_ultra_unsol_event,
12127                 .init_hook = alc262_ultra_automute,
12128         },
12129         [ALC262_LENOVO_3000] = {
12130                 .mixers = { alc262_lenovo_3000_mixer },
12131                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12132                                 alc262_lenovo_3000_unsol_verbs,
12133                                 alc262_lenovo_3000_init_verbs },
12134                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12135                 .dac_nids = alc262_dac_nids,
12136                 .hp_nid = 0x03,
12137                 .dig_out_nid = ALC262_DIGOUT_NID,
12138                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12139                 .channel_mode = alc262_modes,
12140                 .input_mux = &alc262_fujitsu_capture_source,
12141                 .unsol_event = alc262_lenovo_3000_unsol_event,
12142         },
12143         [ALC262_NEC] = {
12144                 .mixers = { alc262_nec_mixer },
12145                 .init_verbs = { alc262_nec_verbs },
12146                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12147                 .dac_nids = alc262_dac_nids,
12148                 .hp_nid = 0x03,
12149                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12150                 .channel_mode = alc262_modes,
12151                 .input_mux = &alc262_capture_source,
12152         },
12153         [ALC262_TOSHIBA_S06] = {
12154                 .mixers = { alc262_toshiba_s06_mixer },
12155                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12156                                                         alc262_eapd_verbs },
12157                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12158                 .capsrc_nids = alc262_dmic_capsrc_nids,
12159                 .dac_nids = alc262_dac_nids,
12160                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12161                 .num_adc_nids = 1, /* single ADC */
12162                 .dig_out_nid = ALC262_DIGOUT_NID,
12163                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12164                 .channel_mode = alc262_modes,
12165                 .unsol_event = alc_sku_unsol_event,
12166                 .setup = alc262_toshiba_s06_setup,
12167                 .init_hook = alc_inithook,
12168         },
12169         [ALC262_TOSHIBA_RX1] = {
12170                 .mixers = { alc262_toshiba_rx1_mixer },
12171                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12172                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12173                 .dac_nids = alc262_dac_nids,
12174                 .hp_nid = 0x03,
12175                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12176                 .channel_mode = alc262_modes,
12177                 .input_mux = &alc262_capture_source,
12178                 .unsol_event = alc262_hippo_unsol_event,
12179                 .setup = alc262_hippo_setup,
12180                 .init_hook = alc262_hippo_automute,
12181         },
12182         [ALC262_TYAN] = {
12183                 .mixers = { alc262_tyan_mixer },
12184                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
12185                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12186                 .dac_nids = alc262_dac_nids,
12187                 .hp_nid = 0x02,
12188                 .dig_out_nid = ALC262_DIGOUT_NID,
12189                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12190                 .channel_mode = alc262_modes,
12191                 .input_mux = &alc262_capture_source,
12192                 .unsol_event = alc_automute_amp_unsol_event,
12193                 .setup = alc262_tyan_setup,
12194                 .init_hook = alc_automute_amp,
12195         },
12196 };
12197
12198 static int patch_alc262(struct hda_codec *codec)
12199 {
12200         struct alc_spec *spec;
12201         int board_config;
12202         int err;
12203
12204         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12205         if (spec == NULL)
12206                 return -ENOMEM;
12207
12208         codec->spec = spec;
12209 #if 0
12210         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
12211          * under-run
12212          */
12213         {
12214         int tmp;
12215         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12216         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
12217         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12218         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
12219         }
12220 #endif
12221
12222         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
12223
12224         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
12225                                                   alc262_models,
12226                                                   alc262_cfg_tbl);
12227
12228         if (board_config < 0) {
12229                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12230                        codec->chip_name);
12231                 board_config = ALC262_AUTO;
12232         }
12233
12234         if (board_config == ALC262_AUTO) {
12235                 /* automatic parse from the BIOS config */
12236                 err = alc262_parse_auto_config(codec);
12237                 if (err < 0) {
12238                         alc_free(codec);
12239                         return err;
12240                 } else if (!err) {
12241                         printk(KERN_INFO
12242                                "hda_codec: Cannot set up configuration "
12243                                "from BIOS.  Using base mode...\n");
12244                         board_config = ALC262_BASIC;
12245                 }
12246         }
12247
12248         if (!spec->no_analog) {
12249                 err = snd_hda_attach_beep_device(codec, 0x1);
12250                 if (err < 0) {
12251                         alc_free(codec);
12252                         return err;
12253                 }
12254         }
12255
12256         if (board_config != ALC262_AUTO)
12257                 setup_preset(codec, &alc262_presets[board_config]);
12258
12259         spec->stream_analog_playback = &alc262_pcm_analog_playback;
12260         spec->stream_analog_capture = &alc262_pcm_analog_capture;
12261
12262         spec->stream_digital_playback = &alc262_pcm_digital_playback;
12263         spec->stream_digital_capture = &alc262_pcm_digital_capture;
12264
12265         if (!spec->adc_nids && spec->input_mux) {
12266                 int i;
12267                 /* check whether the digital-mic has to be supported */
12268                 for (i = 0; i < spec->input_mux->num_items; i++) {
12269                         if (spec->input_mux->items[i].index >= 9)
12270                                 break;
12271                 }
12272                 if (i < spec->input_mux->num_items) {
12273                         /* use only ADC0 */
12274                         spec->adc_nids = alc262_dmic_adc_nids;
12275                         spec->num_adc_nids = 1;
12276                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
12277                 } else {
12278                         /* all analog inputs */
12279                         /* check whether NID 0x07 is valid */
12280                         unsigned int wcap = get_wcaps(codec, 0x07);
12281
12282                         /* get type */
12283                         wcap = get_wcaps_type(wcap);
12284                         if (wcap != AC_WID_AUD_IN) {
12285                                 spec->adc_nids = alc262_adc_nids_alt;
12286                                 spec->num_adc_nids =
12287                                         ARRAY_SIZE(alc262_adc_nids_alt);
12288                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
12289                         } else {
12290                                 spec->adc_nids = alc262_adc_nids;
12291                                 spec->num_adc_nids =
12292                                         ARRAY_SIZE(alc262_adc_nids);
12293                                 spec->capsrc_nids = alc262_capsrc_nids;
12294                         }
12295                 }
12296         }
12297         if (!spec->cap_mixer && !spec->no_analog)
12298                 set_capture_mixer(codec);
12299         if (!spec->no_analog)
12300                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12301
12302         spec->vmaster_nid = 0x0c;
12303
12304         codec->patch_ops = alc_patch_ops;
12305         if (board_config == ALC262_AUTO)
12306                 spec->init_hook = alc262_auto_init;
12307 #ifdef CONFIG_SND_HDA_POWER_SAVE
12308         if (!spec->loopback.amplist)
12309                 spec->loopback.amplist = alc262_loopbacks;
12310 #endif
12311
12312         return 0;
12313 }
12314
12315 /*
12316  *  ALC268 channel source setting (2 channel)
12317  */
12318 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
12319 #define alc268_modes            alc260_modes
12320
12321 static hda_nid_t alc268_dac_nids[2] = {
12322         /* front, hp */
12323         0x02, 0x03
12324 };
12325
12326 static hda_nid_t alc268_adc_nids[2] = {
12327         /* ADC0-1 */
12328         0x08, 0x07
12329 };
12330
12331 static hda_nid_t alc268_adc_nids_alt[1] = {
12332         /* ADC0 */
12333         0x08
12334 };
12335
12336 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
12337
12338 static struct snd_kcontrol_new alc268_base_mixer[] = {
12339         /* output mixer control */
12340         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12341         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12342         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12343         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12344         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12345         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12346         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12347         { }
12348 };
12349
12350 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
12351         /* output mixer control */
12352         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12353         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12354         ALC262_HIPPO_MASTER_SWITCH,
12355         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12356         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12357         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12358         { }
12359 };
12360
12361 /* bind Beep switches of both NID 0x0f and 0x10 */
12362 static struct hda_bind_ctls alc268_bind_beep_sw = {
12363         .ops = &snd_hda_bind_sw,
12364         .values = {
12365                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
12366                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
12367                 0
12368         },
12369 };
12370
12371 static struct snd_kcontrol_new alc268_beep_mixer[] = {
12372         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
12373         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
12374         { }
12375 };
12376
12377 static struct hda_verb alc268_eapd_verbs[] = {
12378         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12379         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12380         { }
12381 };
12382
12383 /* Toshiba specific */
12384 static struct hda_verb alc268_toshiba_verbs[] = {
12385         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12386         { } /* end */
12387 };
12388
12389 /* Acer specific */
12390 /* bind volumes of both NID 0x02 and 0x03 */
12391 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
12392         .ops = &snd_hda_bind_vol,
12393         .values = {
12394                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12395                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12396                 0
12397         },
12398 };
12399
12400 /* mute/unmute internal speaker according to the hp jack and mute state */
12401 static void alc268_acer_automute(struct hda_codec *codec, int force)
12402 {
12403         struct alc_spec *spec = codec->spec;
12404         unsigned int mute;
12405
12406         if (force || !spec->sense_updated) {
12407                 spec->jack_present = snd_hda_jack_detect(codec, 0x14);
12408                 spec->sense_updated = 1;
12409         }
12410         if (spec->jack_present)
12411                 mute = HDA_AMP_MUTE; /* mute internal speaker */
12412         else /* unmute internal speaker if necessary */
12413                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
12414         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12415                                  HDA_AMP_MUTE, mute);
12416 }
12417
12418
12419 /* bind hp and internal speaker mute (with plug check) */
12420 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
12421                                      struct snd_ctl_elem_value *ucontrol)
12422 {
12423         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12424         long *valp = ucontrol->value.integer.value;
12425         int change;
12426
12427         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
12428         if (change)
12429                 alc268_acer_automute(codec, 0);
12430         return change;
12431 }
12432
12433 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
12434         /* output mixer control */
12435         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12436         {
12437                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12438                 .name = "Master Playback Switch",
12439                 .subdevice = HDA_SUBDEV_AMP_FLAG,
12440                 .info = snd_hda_mixer_amp_switch_info,
12441                 .get = snd_hda_mixer_amp_switch_get,
12442                 .put = alc268_acer_master_sw_put,
12443                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12444         },
12445         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
12446         { }
12447 };
12448
12449 static struct snd_kcontrol_new alc268_acer_mixer[] = {
12450         /* output mixer control */
12451         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12452         {
12453                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12454                 .name = "Master Playback Switch",
12455                 .subdevice = HDA_SUBDEV_AMP_FLAG,
12456                 .info = snd_hda_mixer_amp_switch_info,
12457                 .get = snd_hda_mixer_amp_switch_get,
12458                 .put = alc268_acer_master_sw_put,
12459                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12460         },
12461         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12462         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12463         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12464         { }
12465 };
12466
12467 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
12468         /* output mixer control */
12469         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12470         {
12471                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12472                 .name = "Master Playback Switch",
12473                 .subdevice = HDA_SUBDEV_AMP_FLAG,
12474                 .info = snd_hda_mixer_amp_switch_info,
12475                 .get = snd_hda_mixer_amp_switch_get,
12476                 .put = alc268_acer_master_sw_put,
12477                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12478         },
12479         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12480         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12481         { }
12482 };
12483
12484 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
12485         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12486         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12487         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12488         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12489         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
12490         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
12491         { }
12492 };
12493
12494 static struct hda_verb alc268_acer_verbs[] = {
12495         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
12496         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12497         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12498         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12499         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12500         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12501         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12502         { }
12503 };
12504
12505 /* unsolicited event for HP jack sensing */
12506 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
12507 #define alc268_toshiba_setup            alc262_hippo_setup
12508 #define alc268_toshiba_automute         alc262_hippo_automute
12509
12510 static void alc268_acer_unsol_event(struct hda_codec *codec,
12511                                        unsigned int res)
12512 {
12513         if ((res >> 26) != ALC880_HP_EVENT)
12514                 return;
12515         alc268_acer_automute(codec, 1);
12516 }
12517
12518 static void alc268_acer_init_hook(struct hda_codec *codec)
12519 {
12520         alc268_acer_automute(codec, 1);
12521 }
12522
12523 /* toggle speaker-output according to the hp-jack state */
12524 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
12525 {
12526         unsigned int present;
12527         unsigned char bits;
12528
12529         present = snd_hda_jack_detect(codec, 0x15);
12530         bits = present ? HDA_AMP_MUTE : 0;
12531         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
12532                                  HDA_AMP_MUTE, bits);
12533         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
12534                                  HDA_AMP_MUTE, bits);
12535 }
12536
12537 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
12538                                     unsigned int res)
12539 {
12540         switch (res >> 26) {
12541         case ALC880_HP_EVENT:
12542                 alc268_aspire_one_speaker_automute(codec);
12543                 break;
12544         case ALC880_MIC_EVENT:
12545                 alc_mic_automute(codec);
12546                 break;
12547         }
12548 }
12549
12550 static void alc268_acer_lc_setup(struct hda_codec *codec)
12551 {
12552         struct alc_spec *spec = codec->spec;
12553         spec->ext_mic.pin = 0x18;
12554         spec->ext_mic.mux_idx = 0;
12555         spec->int_mic.pin = 0x12;
12556         spec->int_mic.mux_idx = 6;
12557         spec->auto_mic = 1;
12558 }
12559
12560 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
12561 {
12562         alc268_aspire_one_speaker_automute(codec);
12563         alc_mic_automute(codec);
12564 }
12565
12566 static struct snd_kcontrol_new alc268_dell_mixer[] = {
12567         /* output mixer control */
12568         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12569         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12570         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12571         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12572         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12573         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12574         { }
12575 };
12576
12577 static struct hda_verb alc268_dell_verbs[] = {
12578         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12579         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12580         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12581         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12582         { }
12583 };
12584
12585 /* mute/unmute internal speaker according to the hp jack and mute state */
12586 static void alc268_dell_setup(struct hda_codec *codec)
12587 {
12588         struct alc_spec *spec = codec->spec;
12589
12590         spec->autocfg.hp_pins[0] = 0x15;
12591         spec->autocfg.speaker_pins[0] = 0x14;
12592         spec->ext_mic.pin = 0x18;
12593         spec->ext_mic.mux_idx = 0;
12594         spec->int_mic.pin = 0x19;
12595         spec->int_mic.mux_idx = 1;
12596         spec->auto_mic = 1;
12597 }
12598
12599 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
12600         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12601         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12602         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12603         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12604         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12605         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
12606         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
12607         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
12608         { }
12609 };
12610
12611 static struct hda_verb alc267_quanta_il1_verbs[] = {
12612         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12613         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12614         { }
12615 };
12616
12617 static void alc267_quanta_il1_setup(struct hda_codec *codec)
12618 {
12619         struct alc_spec *spec = codec->spec;
12620         spec->autocfg.hp_pins[0] = 0x15;
12621         spec->autocfg.speaker_pins[0] = 0x14;
12622         spec->ext_mic.pin = 0x18;
12623         spec->ext_mic.mux_idx = 0;
12624         spec->int_mic.pin = 0x19;
12625         spec->int_mic.mux_idx = 1;
12626         spec->auto_mic = 1;
12627 }
12628
12629 /*
12630  * generic initialization of ADC, input mixers and output mixers
12631  */
12632 static struct hda_verb alc268_base_init_verbs[] = {
12633         /* Unmute DAC0-1 and set vol = 0 */
12634         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12635         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12636
12637         /*
12638          * Set up output mixers (0x0c - 0x0e)
12639          */
12640         /* set vol=0 to output mixers */
12641         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12642         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
12643
12644         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12645         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12646
12647         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12648         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
12649         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12650         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12651         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12652         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12653         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12654         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12655
12656         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12657         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12658         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12659         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12660         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12661
12662         /* set PCBEEP vol = 0, mute connections */
12663         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12664         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12665         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12666
12667         /* Unmute Selector 23h,24h and set the default input to mic-in */
12668
12669         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
12670         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12671         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
12672         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12673
12674         { }
12675 };
12676
12677 /*
12678  * generic initialization of ADC, input mixers and output mixers
12679  */
12680 static struct hda_verb alc268_volume_init_verbs[] = {
12681         /* set output DAC */
12682         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12683         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12684
12685         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12686         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12687         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12688         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12689         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12690
12691         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12692         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12693         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12694
12695         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12696         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12697
12698         /* set PCBEEP vol = 0, mute connections */
12699         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12700         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12701         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12702
12703         { }
12704 };
12705
12706 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
12707         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12708         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12709         { } /* end */
12710 };
12711
12712 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
12713         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12714         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12715         _DEFINE_CAPSRC(1),
12716         { } /* end */
12717 };
12718
12719 static struct snd_kcontrol_new alc268_capture_mixer[] = {
12720         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12721         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12722         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
12723         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
12724         _DEFINE_CAPSRC(2),
12725         { } /* end */
12726 };
12727
12728 static struct hda_input_mux alc268_capture_source = {
12729         .num_items = 4,
12730         .items = {
12731                 { "Mic", 0x0 },
12732                 { "Front Mic", 0x1 },
12733                 { "Line", 0x2 },
12734                 { "CD", 0x3 },
12735         },
12736 };
12737
12738 static struct hda_input_mux alc268_acer_capture_source = {
12739         .num_items = 3,
12740         .items = {
12741                 { "Mic", 0x0 },
12742                 { "Internal Mic", 0x1 },
12743                 { "Line", 0x2 },
12744         },
12745 };
12746
12747 static struct hda_input_mux alc268_acer_dmic_capture_source = {
12748         .num_items = 3,
12749         .items = {
12750                 { "Mic", 0x0 },
12751                 { "Internal Mic", 0x6 },
12752                 { "Line", 0x2 },
12753         },
12754 };
12755
12756 #ifdef CONFIG_SND_DEBUG
12757 static struct snd_kcontrol_new alc268_test_mixer[] = {
12758         /* Volume widgets */
12759         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12760         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12761         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
12762         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
12763         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
12764         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
12765         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
12766         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
12767         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
12768         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
12769         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
12770         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
12771         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
12772         /* The below appears problematic on some hardwares */
12773         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
12774         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12775         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
12776         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
12777         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
12778
12779         /* Modes for retasking pin widgets */
12780         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
12781         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
12782         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
12783         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
12784
12785         /* Controls for GPIO pins, assuming they are configured as outputs */
12786         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
12787         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
12788         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
12789         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
12790
12791         /* Switches to allow the digital SPDIF output pin to be enabled.
12792          * The ALC268 does not have an SPDIF input.
12793          */
12794         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
12795
12796         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
12797          * this output to turn on an external amplifier.
12798          */
12799         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
12800         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
12801
12802         { } /* end */
12803 };
12804 #endif
12805
12806 /* create input playback/capture controls for the given pin */
12807 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
12808                                     const char *ctlname, int idx)
12809 {
12810         hda_nid_t dac;
12811         int err;
12812
12813         switch (nid) {
12814         case 0x14:
12815         case 0x16:
12816                 dac = 0x02;
12817                 break;
12818         case 0x15:
12819                 dac = 0x03;
12820                 break;
12821         default:
12822                 return 0;
12823         }
12824         if (spec->multiout.dac_nids[0] != dac &&
12825             spec->multiout.dac_nids[1] != dac) {
12826                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
12827                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
12828                                                       HDA_OUTPUT));
12829                 if (err < 0)
12830                         return err;
12831                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
12832         }
12833
12834         if (nid != 0x16)
12835                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12836                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
12837         else /* mono */
12838                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12839                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
12840         if (err < 0)
12841                 return err;
12842         return 0;
12843 }
12844
12845 /* add playback controls from the parsed DAC table */
12846 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
12847                                              const struct auto_pin_cfg *cfg)
12848 {
12849         hda_nid_t nid;
12850         int err;
12851
12852         spec->multiout.dac_nids = spec->private_dac_nids;
12853
12854         nid = cfg->line_out_pins[0];
12855         if (nid) {
12856                 const char *name;
12857                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12858                         name = "Speaker";
12859                 else
12860                         name = "Front";
12861                 err = alc268_new_analog_output(spec, nid, name, 0);
12862                 if (err < 0)
12863                         return err;
12864         }
12865
12866         nid = cfg->speaker_pins[0];
12867         if (nid == 0x1d) {
12868                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
12869                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
12870                 if (err < 0)
12871                         return err;
12872         } else {
12873                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
12874                 if (err < 0)
12875                         return err;
12876         }
12877         nid = cfg->hp_pins[0];
12878         if (nid) {
12879                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
12880                 if (err < 0)
12881                         return err;
12882         }
12883
12884         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
12885         if (nid == 0x16) {
12886                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
12887                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
12888                 if (err < 0)
12889                         return err;
12890         }
12891         return 0;
12892 }
12893
12894 /* create playback/capture controls for input pins */
12895 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
12896                                                 const struct auto_pin_cfg *cfg)
12897 {
12898         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
12899 }
12900
12901 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
12902                                               hda_nid_t nid, int pin_type)
12903 {
12904         int idx;
12905
12906         alc_set_pin_output(codec, nid, pin_type);
12907         if (nid == 0x14 || nid == 0x16)
12908                 idx = 0;
12909         else
12910                 idx = 1;
12911         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
12912 }
12913
12914 static void alc268_auto_init_multi_out(struct hda_codec *codec)
12915 {
12916         struct alc_spec *spec = codec->spec;
12917         hda_nid_t nid = spec->autocfg.line_out_pins[0];
12918         if (nid) {
12919                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
12920                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
12921         }
12922 }
12923
12924 static void alc268_auto_init_hp_out(struct hda_codec *codec)
12925 {
12926         struct alc_spec *spec = codec->spec;
12927         hda_nid_t pin;
12928
12929         pin = spec->autocfg.hp_pins[0];
12930         if (pin)
12931                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
12932         pin = spec->autocfg.speaker_pins[0];
12933         if (pin)
12934                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
12935 }
12936
12937 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
12938 {
12939         struct alc_spec *spec = codec->spec;
12940         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
12941         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
12942         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
12943         unsigned int    dac_vol1, dac_vol2;
12944
12945         if (line_nid == 0x1d || speaker_nid == 0x1d) {
12946                 snd_hda_codec_write(codec, speaker_nid, 0,
12947                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
12948                 /* mute mixer inputs from 0x1d */
12949                 snd_hda_codec_write(codec, 0x0f, 0,
12950                                     AC_VERB_SET_AMP_GAIN_MUTE,
12951                                     AMP_IN_UNMUTE(1));
12952                 snd_hda_codec_write(codec, 0x10, 0,
12953                                     AC_VERB_SET_AMP_GAIN_MUTE,
12954                                     AMP_IN_UNMUTE(1));
12955         } else {
12956                 /* unmute mixer inputs from 0x1d */
12957                 snd_hda_codec_write(codec, 0x0f, 0,
12958                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12959                 snd_hda_codec_write(codec, 0x10, 0,
12960                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12961         }
12962
12963         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
12964         if (line_nid == 0x14)
12965                 dac_vol2 = AMP_OUT_ZERO;
12966         else if (line_nid == 0x15)
12967                 dac_vol1 = AMP_OUT_ZERO;
12968         if (hp_nid == 0x14)
12969                 dac_vol2 = AMP_OUT_ZERO;
12970         else if (hp_nid == 0x15)
12971                 dac_vol1 = AMP_OUT_ZERO;
12972         if (line_nid != 0x16 || hp_nid != 0x16 ||
12973             spec->autocfg.line_out_pins[1] != 0x16 ||
12974             spec->autocfg.line_out_pins[2] != 0x16)
12975                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
12976
12977         snd_hda_codec_write(codec, 0x02, 0,
12978                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
12979         snd_hda_codec_write(codec, 0x03, 0,
12980                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
12981 }
12982
12983 /* pcm configuration: identical with ALC880 */
12984 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
12985 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
12986 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
12987 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
12988
12989 /*
12990  * BIOS auto configuration
12991  */
12992 static int alc268_parse_auto_config(struct hda_codec *codec)
12993 {
12994         struct alc_spec *spec = codec->spec;
12995         int err;
12996         static hda_nid_t alc268_ignore[] = { 0 };
12997
12998         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12999                                            alc268_ignore);
13000         if (err < 0)
13001                 return err;
13002         if (!spec->autocfg.line_outs) {
13003                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13004                         spec->multiout.max_channels = 2;
13005                         spec->no_analog = 1;
13006                         goto dig_only;
13007                 }
13008                 return 0; /* can't find valid BIOS pin config */
13009         }
13010         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13011         if (err < 0)
13012                 return err;
13013         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13014         if (err < 0)
13015                 return err;
13016
13017         spec->multiout.max_channels = 2;
13018
13019  dig_only:
13020         /* digital only support output */
13021         if (spec->autocfg.dig_outs) {
13022                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
13023                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
13024         }
13025         if (spec->kctls.list)
13026                 add_mixer(spec, spec->kctls.list);
13027
13028         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13029                 add_mixer(spec, alc268_beep_mixer);
13030
13031         add_verb(spec, alc268_volume_init_verbs);
13032         spec->num_mux_defs = 2;
13033         spec->input_mux = &spec->private_imux[0];
13034
13035         err = alc_auto_add_mic_boost(codec);
13036         if (err < 0)
13037                 return err;
13038
13039         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13040
13041         return 1;
13042 }
13043
13044 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
13045
13046 /* init callback for auto-configuration model -- overriding the default init */
13047 static void alc268_auto_init(struct hda_codec *codec)
13048 {
13049         struct alc_spec *spec = codec->spec;
13050         alc268_auto_init_multi_out(codec);
13051         alc268_auto_init_hp_out(codec);
13052         alc268_auto_init_mono_speaker_out(codec);
13053         alc268_auto_init_analog_input(codec);
13054         if (spec->unsol_event)
13055                 alc_inithook(codec);
13056 }
13057
13058 /*
13059  * configuration and preset
13060  */
13061 static const char *alc268_models[ALC268_MODEL_LAST] = {
13062         [ALC267_QUANTA_IL1]     = "quanta-il1",
13063         [ALC268_3ST]            = "3stack",
13064         [ALC268_TOSHIBA]        = "toshiba",
13065         [ALC268_ACER]           = "acer",
13066         [ALC268_ACER_DMIC]      = "acer-dmic",
13067         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
13068         [ALC268_DELL]           = "dell",
13069         [ALC268_ZEPTO]          = "zepto",
13070 #ifdef CONFIG_SND_DEBUG
13071         [ALC268_TEST]           = "test",
13072 #endif
13073         [ALC268_AUTO]           = "auto",
13074 };
13075
13076 static struct snd_pci_quirk alc268_cfg_tbl[] = {
13077         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13078         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13079         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13080         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13081         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13082         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13083                                                 ALC268_ACER_ASPIRE_ONE),
13084         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13085         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13086                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13087         /* almost compatible with toshiba but with optional digital outs;
13088          * auto-probing seems working fine
13089          */
13090         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13091                            ALC268_AUTO),
13092         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13093         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13094         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13095         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13096         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13097         SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
13098         {}
13099 };
13100
13101 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
13102 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13103         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13104         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13105         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13106                            ALC268_TOSHIBA),
13107         {}
13108 };
13109
13110 static struct alc_config_preset alc268_presets[] = {
13111         [ALC267_QUANTA_IL1] = {
13112                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13113                             alc268_capture_nosrc_mixer },
13114                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13115                                 alc267_quanta_il1_verbs },
13116                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13117                 .dac_nids = alc268_dac_nids,
13118                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13119                 .adc_nids = alc268_adc_nids_alt,
13120                 .hp_nid = 0x03,
13121                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13122                 .channel_mode = alc268_modes,
13123                 .unsol_event = alc_sku_unsol_event,
13124                 .setup = alc267_quanta_il1_setup,
13125                 .init_hook = alc_inithook,
13126         },
13127         [ALC268_3ST] = {
13128                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13129                             alc268_beep_mixer },
13130                 .init_verbs = { alc268_base_init_verbs },
13131                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13132                 .dac_nids = alc268_dac_nids,
13133                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13134                 .adc_nids = alc268_adc_nids_alt,
13135                 .capsrc_nids = alc268_capsrc_nids,
13136                 .hp_nid = 0x03,
13137                 .dig_out_nid = ALC268_DIGOUT_NID,
13138                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13139                 .channel_mode = alc268_modes,
13140                 .input_mux = &alc268_capture_source,
13141         },
13142         [ALC268_TOSHIBA] = {
13143                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13144                             alc268_beep_mixer },
13145                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13146                                 alc268_toshiba_verbs },
13147                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13148                 .dac_nids = alc268_dac_nids,
13149                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13150                 .adc_nids = alc268_adc_nids_alt,
13151                 .capsrc_nids = alc268_capsrc_nids,
13152                 .hp_nid = 0x03,
13153                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13154                 .channel_mode = alc268_modes,
13155                 .input_mux = &alc268_capture_source,
13156                 .unsol_event = alc268_toshiba_unsol_event,
13157                 .setup = alc268_toshiba_setup,
13158                 .init_hook = alc268_toshiba_automute,
13159         },
13160         [ALC268_ACER] = {
13161                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13162                             alc268_beep_mixer },
13163                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13164                                 alc268_acer_verbs },
13165                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13166                 .dac_nids = alc268_dac_nids,
13167                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13168                 .adc_nids = alc268_adc_nids_alt,
13169                 .capsrc_nids = alc268_capsrc_nids,
13170                 .hp_nid = 0x02,
13171                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13172                 .channel_mode = alc268_modes,
13173                 .input_mux = &alc268_acer_capture_source,
13174                 .unsol_event = alc268_acer_unsol_event,
13175                 .init_hook = alc268_acer_init_hook,
13176         },
13177         [ALC268_ACER_DMIC] = {
13178                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13179                             alc268_beep_mixer },
13180                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13181                                 alc268_acer_verbs },
13182                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13183                 .dac_nids = alc268_dac_nids,
13184                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13185                 .adc_nids = alc268_adc_nids_alt,
13186                 .capsrc_nids = alc268_capsrc_nids,
13187                 .hp_nid = 0x02,
13188                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13189                 .channel_mode = alc268_modes,
13190                 .input_mux = &alc268_acer_dmic_capture_source,
13191                 .unsol_event = alc268_acer_unsol_event,
13192                 .init_hook = alc268_acer_init_hook,
13193         },
13194         [ALC268_ACER_ASPIRE_ONE] = {
13195                 .mixers = { alc268_acer_aspire_one_mixer,
13196                             alc268_beep_mixer,
13197                             alc268_capture_nosrc_mixer },
13198                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13199                                 alc268_acer_aspire_one_verbs },
13200                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13201                 .dac_nids = alc268_dac_nids,
13202                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13203                 .adc_nids = alc268_adc_nids_alt,
13204                 .capsrc_nids = alc268_capsrc_nids,
13205                 .hp_nid = 0x03,
13206                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13207                 .channel_mode = alc268_modes,
13208                 .unsol_event = alc268_acer_lc_unsol_event,
13209                 .setup = alc268_acer_lc_setup,
13210                 .init_hook = alc268_acer_lc_init_hook,
13211         },
13212         [ALC268_DELL] = {
13213                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
13214                             alc268_capture_nosrc_mixer },
13215                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13216                                 alc268_dell_verbs },
13217                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13218                 .dac_nids = alc268_dac_nids,
13219                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13220                 .adc_nids = alc268_adc_nids_alt,
13221                 .capsrc_nids = alc268_capsrc_nids,
13222                 .hp_nid = 0x02,
13223                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13224                 .channel_mode = alc268_modes,
13225                 .unsol_event = alc_sku_unsol_event,
13226                 .setup = alc268_dell_setup,
13227                 .init_hook = alc_inithook,
13228         },
13229         [ALC268_ZEPTO] = {
13230                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13231                             alc268_beep_mixer },
13232                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13233                                 alc268_toshiba_verbs },
13234                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13235                 .dac_nids = alc268_dac_nids,
13236                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13237                 .adc_nids = alc268_adc_nids_alt,
13238                 .capsrc_nids = alc268_capsrc_nids,
13239                 .hp_nid = 0x03,
13240                 .dig_out_nid = ALC268_DIGOUT_NID,
13241                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13242                 .channel_mode = alc268_modes,
13243                 .input_mux = &alc268_capture_source,
13244                 .setup = alc268_toshiba_setup,
13245                 .init_hook = alc268_toshiba_automute,
13246         },
13247 #ifdef CONFIG_SND_DEBUG
13248         [ALC268_TEST] = {
13249                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
13250                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13251                                 alc268_volume_init_verbs },
13252                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13253                 .dac_nids = alc268_dac_nids,
13254                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13255                 .adc_nids = alc268_adc_nids_alt,
13256                 .capsrc_nids = alc268_capsrc_nids,
13257                 .hp_nid = 0x03,
13258                 .dig_out_nid = ALC268_DIGOUT_NID,
13259                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13260                 .channel_mode = alc268_modes,
13261                 .input_mux = &alc268_capture_source,
13262         },
13263 #endif
13264 };
13265
13266 static int patch_alc268(struct hda_codec *codec)
13267 {
13268         struct alc_spec *spec;
13269         int board_config;
13270         int i, has_beep, err;
13271
13272         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13273         if (spec == NULL)
13274                 return -ENOMEM;
13275
13276         codec->spec = spec;
13277
13278         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
13279                                                   alc268_models,
13280                                                   alc268_cfg_tbl);
13281
13282         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
13283                 board_config = snd_hda_check_board_codec_sid_config(codec,
13284                         ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
13285
13286         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
13287                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13288                        codec->chip_name);
13289                 board_config = ALC268_AUTO;
13290         }
13291
13292         if (board_config == ALC268_AUTO) {
13293                 /* automatic parse from the BIOS config */
13294                 err = alc268_parse_auto_config(codec);
13295                 if (err < 0) {
13296                         alc_free(codec);
13297                         return err;
13298                 } else if (!err) {
13299                         printk(KERN_INFO
13300                                "hda_codec: Cannot set up configuration "
13301                                "from BIOS.  Using base mode...\n");
13302                         board_config = ALC268_3ST;
13303                 }
13304         }
13305
13306         if (board_config != ALC268_AUTO)
13307                 setup_preset(codec, &alc268_presets[board_config]);
13308
13309         spec->stream_analog_playback = &alc268_pcm_analog_playback;
13310         spec->stream_analog_capture = &alc268_pcm_analog_capture;
13311         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
13312
13313         spec->stream_digital_playback = &alc268_pcm_digital_playback;
13314
13315         has_beep = 0;
13316         for (i = 0; i < spec->num_mixers; i++) {
13317                 if (spec->mixers[i] == alc268_beep_mixer) {
13318                         has_beep = 1;
13319                         break;
13320                 }
13321         }
13322
13323         if (has_beep) {
13324                 err = snd_hda_attach_beep_device(codec, 0x1);
13325                 if (err < 0) {
13326                         alc_free(codec);
13327                         return err;
13328                 }
13329                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
13330                         /* override the amp caps for beep generator */
13331                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
13332                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
13333                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
13334                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
13335                                           (0 << AC_AMPCAP_MUTE_SHIFT));
13336         }
13337
13338         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
13339                 /* check whether NID 0x07 is valid */
13340                 unsigned int wcap = get_wcaps(codec, 0x07);
13341                 int i;
13342
13343                 spec->capsrc_nids = alc268_capsrc_nids;
13344                 /* get type */
13345                 wcap = get_wcaps_type(wcap);
13346                 if (spec->auto_mic ||
13347                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
13348                         spec->adc_nids = alc268_adc_nids_alt;
13349                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
13350                         if (spec->auto_mic)
13351                                 fixup_automic_adc(codec);
13352                         if (spec->auto_mic || spec->input_mux->num_items == 1)
13353                                 add_mixer(spec, alc268_capture_nosrc_mixer);
13354                         else
13355                                 add_mixer(spec, alc268_capture_alt_mixer);
13356                 } else {
13357                         spec->adc_nids = alc268_adc_nids;
13358                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
13359                         add_mixer(spec, alc268_capture_mixer);
13360                 }
13361                 /* set default input source */
13362                 for (i = 0; i < spec->num_adc_nids; i++)
13363                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
13364                                 0, AC_VERB_SET_CONNECT_SEL,
13365                                 i < spec->num_mux_defs ?
13366                                 spec->input_mux[i].items[0].index :
13367                                 spec->input_mux->items[0].index);
13368         }
13369
13370         spec->vmaster_nid = 0x02;
13371
13372         codec->patch_ops = alc_patch_ops;
13373         if (board_config == ALC268_AUTO)
13374                 spec->init_hook = alc268_auto_init;
13375
13376         return 0;
13377 }
13378
13379 /*
13380  *  ALC269 channel source setting (2 channel)
13381  */
13382 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
13383
13384 #define alc269_dac_nids         alc260_dac_nids
13385
13386 static hda_nid_t alc269_adc_nids[1] = {
13387         /* ADC1 */
13388         0x08,
13389 };
13390
13391 static hda_nid_t alc269_capsrc_nids[1] = {
13392         0x23,
13393 };
13394
13395 static hda_nid_t alc269vb_adc_nids[1] = {
13396         /* ADC1 */
13397         0x09,
13398 };
13399
13400 static hda_nid_t alc269vb_capsrc_nids[1] = {
13401         0x22,
13402 };
13403
13404 static hda_nid_t alc269_adc_candidates[] = {
13405         0x08, 0x09, 0x07,
13406 };
13407
13408 #define alc269_modes            alc260_modes
13409 #define alc269_capture_source   alc880_lg_lw_capture_source
13410
13411 static struct snd_kcontrol_new alc269_base_mixer[] = {
13412         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13413         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13414         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13415         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13416         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13417         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13418         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13419         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13420         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13421         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13422         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13423         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
13424         { } /* end */
13425 };
13426
13427 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
13428         /* output mixer control */
13429         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13430         {
13431                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13432                 .name = "Master Playback Switch",
13433                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13434                 .info = snd_hda_mixer_amp_switch_info,
13435                 .get = snd_hda_mixer_amp_switch_get,
13436                 .put = alc268_acer_master_sw_put,
13437                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13438         },
13439         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13440         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13441         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13442         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13443         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13444         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13445         { }
13446 };
13447
13448 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
13449         /* output mixer control */
13450         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13451         {
13452                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13453                 .name = "Master Playback Switch",
13454                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13455                 .info = snd_hda_mixer_amp_switch_info,
13456                 .get = snd_hda_mixer_amp_switch_get,
13457                 .put = alc268_acer_master_sw_put,
13458                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13459         },
13460         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13461         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13462         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13463         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13464         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13465         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13466         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
13467         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
13468         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
13469         { }
13470 };
13471
13472 static struct snd_kcontrol_new alc269_laptop_mixer[] = {
13473         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13474         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13475         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13476         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13477         { } /* end */
13478 };
13479
13480 static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
13481         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13482         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13483         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
13484         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13485         { } /* end */
13486 };
13487
13488 /* capture mixer elements */
13489 static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
13490         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13491         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13492         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13493         HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
13494         { } /* end */
13495 };
13496
13497 static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
13498         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13499         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13500         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13501         { } /* end */
13502 };
13503
13504 static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
13505         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13506         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13507         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13508         HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
13509         { } /* end */
13510 };
13511
13512 static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
13513         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13514         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13515         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13516         { } /* end */
13517 };
13518
13519 /* FSC amilo */
13520 #define alc269_fujitsu_mixer    alc269_laptop_mixer
13521
13522 static struct hda_verb alc269_quanta_fl1_verbs[] = {
13523         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13524         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13525         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13526         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13527         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13528         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13529         { }
13530 };
13531
13532 static struct hda_verb alc269_lifebook_verbs[] = {
13533         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13534         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
13535         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13536         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13537         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13538         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13539         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13540         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13541         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13542         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13543         { }
13544 };
13545
13546 /* toggle speaker-output according to the hp-jack state */
13547 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
13548 {
13549         unsigned int present;
13550         unsigned char bits;
13551
13552         present = snd_hda_jack_detect(codec, 0x15);
13553         bits = present ? HDA_AMP_MUTE : 0;
13554         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13555                                  HDA_AMP_MUTE, bits);
13556         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13557                                  HDA_AMP_MUTE, bits);
13558
13559         snd_hda_codec_write(codec, 0x20, 0,
13560                         AC_VERB_SET_COEF_INDEX, 0x0c);
13561         snd_hda_codec_write(codec, 0x20, 0,
13562                         AC_VERB_SET_PROC_COEF, 0x680);
13563
13564         snd_hda_codec_write(codec, 0x20, 0,
13565                         AC_VERB_SET_COEF_INDEX, 0x0c);
13566         snd_hda_codec_write(codec, 0x20, 0,
13567                         AC_VERB_SET_PROC_COEF, 0x480);
13568 }
13569
13570 /* toggle speaker-output according to the hp-jacks state */
13571 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
13572 {
13573         unsigned int present;
13574         unsigned char bits;
13575
13576         /* Check laptop headphone socket */
13577         present = snd_hda_jack_detect(codec, 0x15);
13578
13579         /* Check port replicator headphone socket */
13580         present |= snd_hda_jack_detect(codec, 0x1a);
13581
13582         bits = present ? HDA_AMP_MUTE : 0;
13583         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13584                                  HDA_AMP_MUTE, bits);
13585         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13586                                  HDA_AMP_MUTE, bits);
13587
13588         snd_hda_codec_write(codec, 0x20, 0,
13589                         AC_VERB_SET_COEF_INDEX, 0x0c);
13590         snd_hda_codec_write(codec, 0x20, 0,
13591                         AC_VERB_SET_PROC_COEF, 0x680);
13592
13593         snd_hda_codec_write(codec, 0x20, 0,
13594                         AC_VERB_SET_COEF_INDEX, 0x0c);
13595         snd_hda_codec_write(codec, 0x20, 0,
13596                         AC_VERB_SET_PROC_COEF, 0x480);
13597 }
13598
13599 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
13600 {
13601         unsigned int present_laptop;
13602         unsigned int present_dock;
13603
13604         present_laptop  = snd_hda_jack_detect(codec, 0x18);
13605         present_dock    = snd_hda_jack_detect(codec, 0x1b);
13606
13607         /* Laptop mic port overrides dock mic port, design decision */
13608         if (present_dock)
13609                 snd_hda_codec_write(codec, 0x23, 0,
13610                                 AC_VERB_SET_CONNECT_SEL, 0x3);
13611         if (present_laptop)
13612                 snd_hda_codec_write(codec, 0x23, 0,
13613                                 AC_VERB_SET_CONNECT_SEL, 0x0);
13614         if (!present_dock && !present_laptop)
13615                 snd_hda_codec_write(codec, 0x23, 0,
13616                                 AC_VERB_SET_CONNECT_SEL, 0x1);
13617 }
13618
13619 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
13620                                     unsigned int res)
13621 {
13622         switch (res >> 26) {
13623         case ALC880_HP_EVENT:
13624                 alc269_quanta_fl1_speaker_automute(codec);
13625                 break;
13626         case ALC880_MIC_EVENT:
13627                 alc_mic_automute(codec);
13628                 break;
13629         }
13630 }
13631
13632 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
13633                                         unsigned int res)
13634 {
13635         if ((res >> 26) == ALC880_HP_EVENT)
13636                 alc269_lifebook_speaker_automute(codec);
13637         if ((res >> 26) == ALC880_MIC_EVENT)
13638                 alc269_lifebook_mic_autoswitch(codec);
13639 }
13640
13641 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
13642 {
13643         struct alc_spec *spec = codec->spec;
13644         spec->autocfg.hp_pins[0] = 0x15;
13645         spec->autocfg.speaker_pins[0] = 0x14;
13646         spec->ext_mic.pin = 0x18;
13647         spec->ext_mic.mux_idx = 0;
13648         spec->int_mic.pin = 0x19;
13649         spec->int_mic.mux_idx = 1;
13650         spec->auto_mic = 1;
13651 }
13652
13653 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
13654 {
13655         alc269_quanta_fl1_speaker_automute(codec);
13656         alc_mic_automute(codec);
13657 }
13658
13659 static void alc269_lifebook_init_hook(struct hda_codec *codec)
13660 {
13661         alc269_lifebook_speaker_automute(codec);
13662         alc269_lifebook_mic_autoswitch(codec);
13663 }
13664
13665 static struct hda_verb alc269_laptop_dmic_init_verbs[] = {
13666         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13667         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
13668         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13669         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13670         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13671         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13672         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13673         {}
13674 };
13675
13676 static struct hda_verb alc269_laptop_amic_init_verbs[] = {
13677         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13678         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
13679         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13680         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
13681         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13682         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13683         {}
13684 };
13685
13686 static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
13687         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
13688         {0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
13689         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13690         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13691         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13692         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13693         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13694         {}
13695 };
13696
13697 static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
13698         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
13699         {0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
13700         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13701         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13702         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13703         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13704         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13705         {}
13706 };
13707
13708 /* toggle speaker-output according to the hp-jack state */
13709 static void alc269_speaker_automute(struct hda_codec *codec)
13710 {
13711         struct alc_spec *spec = codec->spec;
13712         unsigned int nid = spec->autocfg.hp_pins[0];
13713         unsigned int present;
13714         unsigned char bits;
13715
13716         present = snd_hda_jack_detect(codec, nid);
13717         bits = present ? HDA_AMP_MUTE : 0;
13718         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13719                                  HDA_AMP_MUTE, bits);
13720         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13721                                  HDA_AMP_MUTE, bits);
13722 }
13723
13724 /* unsolicited event for HP jack sensing */
13725 static void alc269_laptop_unsol_event(struct hda_codec *codec,
13726                                      unsigned int res)
13727 {
13728         switch (res >> 26) {
13729         case ALC880_HP_EVENT:
13730                 alc269_speaker_automute(codec);
13731                 break;
13732         case ALC880_MIC_EVENT:
13733                 alc_mic_automute(codec);
13734                 break;
13735         }
13736 }
13737
13738 static void alc269_laptop_dmic_setup(struct hda_codec *codec)
13739 {
13740         struct alc_spec *spec = codec->spec;
13741         spec->autocfg.hp_pins[0] = 0x15;
13742         spec->autocfg.speaker_pins[0] = 0x14;
13743         spec->ext_mic.pin = 0x18;
13744         spec->ext_mic.mux_idx = 0;
13745         spec->int_mic.pin = 0x12;
13746         spec->int_mic.mux_idx = 5;
13747         spec->auto_mic = 1;
13748 }
13749
13750 static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
13751 {
13752         struct alc_spec *spec = codec->spec;
13753         spec->autocfg.hp_pins[0] = 0x15;
13754         spec->autocfg.speaker_pins[0] = 0x14;
13755         spec->ext_mic.pin = 0x18;
13756         spec->ext_mic.mux_idx = 0;
13757         spec->int_mic.pin = 0x12;
13758         spec->int_mic.mux_idx = 6;
13759         spec->auto_mic = 1;
13760 }
13761
13762 static void alc269_laptop_amic_setup(struct hda_codec *codec)
13763 {
13764         struct alc_spec *spec = codec->spec;
13765         spec->autocfg.hp_pins[0] = 0x15;
13766         spec->autocfg.speaker_pins[0] = 0x14;
13767         spec->ext_mic.pin = 0x18;
13768         spec->ext_mic.mux_idx = 0;
13769         spec->int_mic.pin = 0x19;
13770         spec->int_mic.mux_idx = 1;
13771         spec->auto_mic = 1;
13772 }
13773
13774 static void alc269_laptop_inithook(struct hda_codec *codec)
13775 {
13776         alc269_speaker_automute(codec);
13777         alc_mic_automute(codec);
13778 }
13779
13780 /*
13781  * generic initialization of ADC, input mixers and output mixers
13782  */
13783 static struct hda_verb alc269_init_verbs[] = {
13784         /*
13785          * Unmute ADC0 and set the default input to mic-in
13786          */
13787         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13788
13789         /*
13790          * Set up output mixers (0x02 - 0x03)
13791          */
13792         /* set vol=0 to output mixers */
13793         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13794         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13795
13796         /* set up input amps for analog loopback */
13797         /* Amp Indices: DAC = 0, mixer = 1 */
13798         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13799         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13800         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13801         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13802         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13803         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13804
13805         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13806         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13807         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13808         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13809         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13810         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13811         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13812
13813         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13814         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13815
13816         /* FIXME: use Mux-type input source selection */
13817         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13818         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13819         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13820
13821         /* set EAPD */
13822         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13823         { }
13824 };
13825
13826 static struct hda_verb alc269vb_init_verbs[] = {
13827         /*
13828          * Unmute ADC0 and set the default input to mic-in
13829          */
13830         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13831
13832         /*
13833          * Set up output mixers (0x02 - 0x03)
13834          */
13835         /* set vol=0 to output mixers */
13836         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13837         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13838
13839         /* set up input amps for analog loopback */
13840         /* Amp Indices: DAC = 0, mixer = 1 */
13841         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13842         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13843         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13844         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13845         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13846         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13847
13848         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13849         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13850         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13851         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13852         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13853         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13854         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13855
13856         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13857         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13858
13859         /* FIXME: use Mux-type input source selection */
13860         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13861         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13862         {0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
13863
13864         /* set EAPD */
13865         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13866         { }
13867 };
13868
13869 #define alc269_auto_create_multi_out_ctls \
13870         alc268_auto_create_multi_out_ctls
13871 #define alc269_auto_create_input_ctls \
13872         alc268_auto_create_input_ctls
13873
13874 #ifdef CONFIG_SND_HDA_POWER_SAVE
13875 #define alc269_loopbacks        alc880_loopbacks
13876 #endif
13877
13878 /* pcm configuration: identical with ALC880 */
13879 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
13880 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
13881 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
13882 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
13883
13884 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
13885         .substreams = 1,
13886         .channels_min = 2,
13887         .channels_max = 8,
13888         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13889         /* NID is set in alc_build_pcms */
13890         .ops = {
13891                 .open = alc880_playback_pcm_open,
13892                 .prepare = alc880_playback_pcm_prepare,
13893                 .cleanup = alc880_playback_pcm_cleanup
13894         },
13895 };
13896
13897 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
13898         .substreams = 1,
13899         .channels_min = 2,
13900         .channels_max = 2,
13901         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13902         /* NID is set in alc_build_pcms */
13903 };
13904
13905 /*
13906  * BIOS auto configuration
13907  */
13908 static int alc269_parse_auto_config(struct hda_codec *codec)
13909 {
13910         struct alc_spec *spec = codec->spec;
13911         int err;
13912         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
13913
13914         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13915                                            alc269_ignore);
13916         if (err < 0)
13917                 return err;
13918
13919         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
13920         if (err < 0)
13921                 return err;
13922         err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
13923         if (err < 0)
13924                 return err;
13925
13926         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13927
13928         if (spec->autocfg.dig_outs)
13929                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
13930
13931         if (spec->kctls.list)
13932                 add_mixer(spec, spec->kctls.list);
13933
13934         if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010) {
13935                 add_verb(spec, alc269vb_init_verbs);
13936                 alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
13937         } else {
13938                 add_verb(spec, alc269_init_verbs);
13939                 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13940         }
13941
13942         spec->num_mux_defs = 1;
13943         spec->input_mux = &spec->private_imux[0];
13944         fillup_priv_adc_nids(codec, alc269_adc_candidates,
13945                              sizeof(alc269_adc_candidates));
13946
13947         /* set default input source */
13948         snd_hda_codec_write_cache(codec, spec->capsrc_nids[0],
13949                                   0, AC_VERB_SET_CONNECT_SEL,
13950                                   spec->input_mux->items[0].index);
13951
13952         err = alc_auto_add_mic_boost(codec);
13953         if (err < 0)
13954                 return err;
13955
13956         if (!spec->cap_mixer && !spec->no_analog)
13957                 set_capture_mixer(codec);
13958
13959         return 1;
13960 }
13961
13962 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
13963 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
13964 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
13965
13966
13967 /* init callback for auto-configuration model -- overriding the default init */
13968 static void alc269_auto_init(struct hda_codec *codec)
13969 {
13970         struct alc_spec *spec = codec->spec;
13971         alc269_auto_init_multi_out(codec);
13972         alc269_auto_init_hp_out(codec);
13973         alc269_auto_init_analog_input(codec);
13974         if (spec->unsol_event)
13975                 alc_inithook(codec);
13976 }
13977
13978 /*
13979  * configuration and preset
13980  */
13981 static const char *alc269_models[ALC269_MODEL_LAST] = {
13982         [ALC269_BASIC]                  = "basic",
13983         [ALC269_QUANTA_FL1]             = "quanta",
13984         [ALC269_AMIC]                   = "laptop-amic",
13985         [ALC269_DMIC]                   = "laptop-dmic",
13986         [ALC269_FUJITSU]                = "fujitsu",
13987         [ALC269_LIFEBOOK]               = "lifebook",
13988         [ALC269_AUTO]                   = "auto",
13989 };
13990
13991 static struct snd_pci_quirk alc269_cfg_tbl[] = {
13992         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
13993         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
13994                       ALC269_AMIC),
13995         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
13996         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
13997         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
13998         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
13999         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
14000         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
14001         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
14002         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
14003         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
14004         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_AMIC),
14005         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
14006         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
14007         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
14008         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
14009         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
14010         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
14011         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
14012         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
14013         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
14014         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
14015         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
14016         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
14017         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
14018         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
14019         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
14020         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
14021         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
14022         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
14023         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
14024         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
14025         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
14026         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
14027         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
14028         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
14029         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
14030         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
14031         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
14032                       ALC269_DMIC),
14033         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
14034                       ALC269_DMIC),
14035         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
14036         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
14037         SND_PCI_QUIRK(0x104d, 0x9071, "SONY XTB", ALC269_DMIC),
14038         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
14039         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
14040         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
14041         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
14042         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
14043         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
14044         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
14045         {}
14046 };
14047
14048 static struct alc_config_preset alc269_presets[] = {
14049         [ALC269_BASIC] = {
14050                 .mixers = { alc269_base_mixer },
14051                 .init_verbs = { alc269_init_verbs },
14052                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14053                 .dac_nids = alc269_dac_nids,
14054                 .hp_nid = 0x03,
14055                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14056                 .channel_mode = alc269_modes,
14057                 .input_mux = &alc269_capture_source,
14058         },
14059         [ALC269_QUANTA_FL1] = {
14060                 .mixers = { alc269_quanta_fl1_mixer },
14061                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
14062                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14063                 .dac_nids = alc269_dac_nids,
14064                 .hp_nid = 0x03,
14065                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14066                 .channel_mode = alc269_modes,
14067                 .input_mux = &alc269_capture_source,
14068                 .unsol_event = alc269_quanta_fl1_unsol_event,
14069                 .setup = alc269_quanta_fl1_setup,
14070                 .init_hook = alc269_quanta_fl1_init_hook,
14071         },
14072         [ALC269_AMIC] = {
14073                 .mixers = { alc269_laptop_mixer },
14074                 .cap_mixer = alc269_laptop_analog_capture_mixer,
14075                 .init_verbs = { alc269_init_verbs,
14076                                 alc269_laptop_amic_init_verbs },
14077                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14078                 .dac_nids = alc269_dac_nids,
14079                 .hp_nid = 0x03,
14080                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14081                 .channel_mode = alc269_modes,
14082                 .unsol_event = alc269_laptop_unsol_event,
14083                 .setup = alc269_laptop_amic_setup,
14084                 .init_hook = alc269_laptop_inithook,
14085         },
14086         [ALC269_DMIC] = {
14087                 .mixers = { alc269_laptop_mixer },
14088                 .cap_mixer = alc269_laptop_digital_capture_mixer,
14089                 .init_verbs = { alc269_init_verbs,
14090                                 alc269_laptop_dmic_init_verbs },
14091                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14092                 .dac_nids = alc269_dac_nids,
14093                 .hp_nid = 0x03,
14094                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14095                 .channel_mode = alc269_modes,
14096                 .unsol_event = alc269_laptop_unsol_event,
14097                 .setup = alc269_laptop_dmic_setup,
14098                 .init_hook = alc269_laptop_inithook,
14099         },
14100         [ALC269VB_AMIC] = {
14101                 .mixers = { alc269vb_laptop_mixer },
14102                 .cap_mixer = alc269vb_laptop_analog_capture_mixer,
14103                 .init_verbs = { alc269vb_init_verbs,
14104                                 alc269vb_laptop_amic_init_verbs },
14105                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14106                 .dac_nids = alc269_dac_nids,
14107                 .hp_nid = 0x03,
14108                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14109                 .channel_mode = alc269_modes,
14110                 .unsol_event = alc269_laptop_unsol_event,
14111                 .setup = alc269_laptop_amic_setup,
14112                 .init_hook = alc269_laptop_inithook,
14113         },
14114         [ALC269VB_DMIC] = {
14115                 .mixers = { alc269vb_laptop_mixer },
14116                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
14117                 .init_verbs = { alc269vb_init_verbs,
14118                                 alc269vb_laptop_dmic_init_verbs },
14119                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14120                 .dac_nids = alc269_dac_nids,
14121                 .hp_nid = 0x03,
14122                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14123                 .channel_mode = alc269_modes,
14124                 .unsol_event = alc269_laptop_unsol_event,
14125                 .setup = alc269vb_laptop_dmic_setup,
14126                 .init_hook = alc269_laptop_inithook,
14127         },
14128         [ALC269_FUJITSU] = {
14129                 .mixers = { alc269_fujitsu_mixer },
14130                 .cap_mixer = alc269_laptop_digital_capture_mixer,
14131                 .init_verbs = { alc269_init_verbs,
14132                                 alc269_laptop_dmic_init_verbs },
14133                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14134                 .dac_nids = alc269_dac_nids,
14135                 .hp_nid = 0x03,
14136                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14137                 .channel_mode = alc269_modes,
14138                 .unsol_event = alc269_laptop_unsol_event,
14139                 .setup = alc269_laptop_dmic_setup,
14140                 .init_hook = alc269_laptop_inithook,
14141         },
14142         [ALC269_LIFEBOOK] = {
14143                 .mixers = { alc269_lifebook_mixer },
14144                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
14145                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14146                 .dac_nids = alc269_dac_nids,
14147                 .hp_nid = 0x03,
14148                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14149                 .channel_mode = alc269_modes,
14150                 .input_mux = &alc269_capture_source,
14151                 .unsol_event = alc269_lifebook_unsol_event,
14152                 .init_hook = alc269_lifebook_init_hook,
14153         },
14154 };
14155
14156 static int patch_alc269(struct hda_codec *codec)
14157 {
14158         struct alc_spec *spec;
14159         int board_config;
14160         int err;
14161         int is_alc269vb = 0;
14162
14163         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14164         if (spec == NULL)
14165                 return -ENOMEM;
14166
14167         codec->spec = spec;
14168
14169         alc_fix_pll_init(codec, 0x20, 0x04, 15);
14170
14171         if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010){
14172                 kfree(codec->chip_name);
14173                 codec->chip_name = kstrdup("ALC259", GFP_KERNEL);
14174                 if (!codec->chip_name) {
14175                         alc_free(codec);
14176                         return -ENOMEM;
14177                 }
14178                 is_alc269vb = 1;
14179         }
14180
14181         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
14182                                                   alc269_models,
14183                                                   alc269_cfg_tbl);
14184
14185         if (board_config < 0) {
14186                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14187                        codec->chip_name);
14188                 board_config = ALC269_AUTO;
14189         }
14190
14191         if (board_config == ALC269_AUTO) {
14192                 /* automatic parse from the BIOS config */
14193                 err = alc269_parse_auto_config(codec);
14194                 if (err < 0) {
14195                         alc_free(codec);
14196                         return err;
14197                 } else if (!err) {
14198                         printk(KERN_INFO
14199                                "hda_codec: Cannot set up configuration "
14200                                "from BIOS.  Using base mode...\n");
14201                         board_config = ALC269_BASIC;
14202                 }
14203         }
14204
14205         err = snd_hda_attach_beep_device(codec, 0x1);
14206         if (err < 0) {
14207                 alc_free(codec);
14208                 return err;
14209         }
14210
14211         if (board_config != ALC269_AUTO)
14212                 setup_preset(codec, &alc269_presets[board_config]);
14213
14214         if (board_config == ALC269_QUANTA_FL1) {
14215                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
14216                  * fix the sample rate of analog I/O to 44.1kHz
14217                  */
14218                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
14219                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
14220         } else {
14221                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
14222                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
14223         }
14224         spec->stream_digital_playback = &alc269_pcm_digital_playback;
14225         spec->stream_digital_capture = &alc269_pcm_digital_capture;
14226
14227         if (!spec->adc_nids) { /* wasn't filled automatically? use default */
14228                 if (!is_alc269vb) {
14229                         spec->adc_nids = alc269_adc_nids;
14230                         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
14231                         spec->capsrc_nids = alc269_capsrc_nids;
14232                 } else {
14233                         spec->adc_nids = alc269vb_adc_nids;
14234                         spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
14235                         spec->capsrc_nids = alc269vb_capsrc_nids;
14236                 }
14237         }
14238
14239         if (!spec->cap_mixer)
14240                 set_capture_mixer(codec);
14241         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
14242
14243         spec->vmaster_nid = 0x02;
14244
14245         codec->patch_ops = alc_patch_ops;
14246         if (board_config == ALC269_AUTO)
14247                 spec->init_hook = alc269_auto_init;
14248 #ifdef CONFIG_SND_HDA_POWER_SAVE
14249         if (!spec->loopback.amplist)
14250                 spec->loopback.amplist = alc269_loopbacks;
14251 #endif
14252
14253         return 0;
14254 }
14255
14256 /*
14257  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
14258  */
14259
14260 /*
14261  * set the path ways for 2 channel output
14262  * need to set the codec line out and mic 1 pin widgets to inputs
14263  */
14264 static struct hda_verb alc861_threestack_ch2_init[] = {
14265         /* set pin widget 1Ah (line in) for input */
14266         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14267         /* set pin widget 18h (mic1/2) for input, for mic also enable
14268          * the vref
14269          */
14270         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14271
14272         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
14273 #if 0
14274         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14275         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
14276 #endif
14277         { } /* end */
14278 };
14279 /*
14280  * 6ch mode
14281  * need to set the codec line out and mic 1 pin widgets to outputs
14282  */
14283 static struct hda_verb alc861_threestack_ch6_init[] = {
14284         /* set pin widget 1Ah (line in) for output (Back Surround)*/
14285         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14286         /* set pin widget 18h (mic1) for output (CLFE)*/
14287         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14288
14289         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
14290         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
14291
14292         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
14293 #if 0
14294         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14295         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
14296 #endif
14297         { } /* end */
14298 };
14299
14300 static struct hda_channel_mode alc861_threestack_modes[2] = {
14301         { 2, alc861_threestack_ch2_init },
14302         { 6, alc861_threestack_ch6_init },
14303 };
14304 /* Set mic1 as input and unmute the mixer */
14305 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
14306         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14307         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14308         { } /* end */
14309 };
14310 /* Set mic1 as output and mute mixer */
14311 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
14312         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14313         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14314         { } /* end */
14315 };
14316
14317 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
14318         { 2, alc861_uniwill_m31_ch2_init },
14319         { 4, alc861_uniwill_m31_ch4_init },
14320 };
14321
14322 /* Set mic1 and line-in as input and unmute the mixer */
14323 static struct hda_verb alc861_asus_ch2_init[] = {
14324         /* set pin widget 1Ah (line in) for input */
14325         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14326         /* set pin widget 18h (mic1/2) for input, for mic also enable
14327          * the vref
14328          */
14329         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14330
14331         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
14332 #if 0
14333         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14334         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
14335 #endif
14336         { } /* end */
14337 };
14338 /* Set mic1 nad line-in as output and mute mixer */
14339 static struct hda_verb alc861_asus_ch6_init[] = {
14340         /* set pin widget 1Ah (line in) for output (Back Surround)*/
14341         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14342         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
14343         /* set pin widget 18h (mic1) for output (CLFE)*/
14344         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14345         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
14346         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
14347         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
14348
14349         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
14350 #if 0
14351         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14352         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
14353 #endif
14354         { } /* end */
14355 };
14356
14357 static struct hda_channel_mode alc861_asus_modes[2] = {
14358         { 2, alc861_asus_ch2_init },
14359         { 6, alc861_asus_ch6_init },
14360 };
14361
14362 /* patch-ALC861 */
14363
14364 static struct snd_kcontrol_new alc861_base_mixer[] = {
14365         /* output mixer control */
14366         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14367         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14368         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14369         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14370         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
14371
14372         /*Input mixer control */
14373         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14374            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14375         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14376         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14377         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14378         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14379         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14380         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14381         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14382         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14383
14384         { } /* end */
14385 };
14386
14387 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
14388         /* output mixer control */
14389         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14390         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14391         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14392         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14393         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
14394
14395         /* Input mixer control */
14396         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14397            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14398         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14399         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14400         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14401         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14402         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14403         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14404         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14405         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14406
14407         {
14408                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14409                 .name = "Channel Mode",
14410                 .info = alc_ch_mode_info,
14411                 .get = alc_ch_mode_get,
14412                 .put = alc_ch_mode_put,
14413                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
14414         },
14415         { } /* end */
14416 };
14417
14418 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
14419         /* output mixer control */
14420         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14421         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14422         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14423
14424         { } /* end */
14425 };
14426
14427 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
14428         /* output mixer control */
14429         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14430         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14431         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14432         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14433         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
14434
14435         /* Input mixer control */
14436         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14437            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14438         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14439         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14440         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14441         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14442         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14443         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14444         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14445         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14446
14447         {
14448                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14449                 .name = "Channel Mode",
14450                 .info = alc_ch_mode_info,
14451                 .get = alc_ch_mode_get,
14452                 .put = alc_ch_mode_put,
14453                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
14454         },
14455         { } /* end */
14456 };
14457
14458 static struct snd_kcontrol_new alc861_asus_mixer[] = {
14459         /* output mixer control */
14460         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14461         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14462         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14463         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14464         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
14465
14466         /* Input mixer control */
14467         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14468         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14469         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14470         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14471         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14472         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14473         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14474         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14475         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14476         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
14477
14478         {
14479                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14480                 .name = "Channel Mode",
14481                 .info = alc_ch_mode_info,
14482                 .get = alc_ch_mode_get,
14483                 .put = alc_ch_mode_put,
14484                 .private_value = ARRAY_SIZE(alc861_asus_modes),
14485         },
14486         { }
14487 };
14488
14489 /* additional mixer */
14490 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
14491         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14492         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14493         { }
14494 };
14495
14496 /*
14497  * generic initialization of ADC, input mixers and output mixers
14498  */
14499 static struct hda_verb alc861_base_init_verbs[] = {
14500         /*
14501          * Unmute ADC0 and set the default input to mic-in
14502          */
14503         /* port-A for surround (rear panel) */
14504         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14505         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
14506         /* port-B for mic-in (rear panel) with vref */
14507         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14508         /* port-C for line-in (rear panel) */
14509         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14510         /* port-D for Front */
14511         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14512         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14513         /* port-E for HP out (front panel) */
14514         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14515         /* route front PCM to HP */
14516         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14517         /* port-F for mic-in (front panel) with vref */
14518         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14519         /* port-G for CLFE (rear panel) */
14520         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14521         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14522         /* port-H for side (rear panel) */
14523         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14524         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
14525         /* CD-in */
14526         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14527         /* route front mic to ADC1*/
14528         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14529         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14530
14531         /* Unmute DAC0~3 & spdif out*/
14532         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14533         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14534         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14535         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14536         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14537
14538         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14539         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14540         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14541         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14542         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14543
14544         /* Unmute Stereo Mixer 15 */
14545         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14546         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14547         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14548         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14549
14550         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14551         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14552         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14553         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14554         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14555         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14556         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14557         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14558         /* hp used DAC 3 (Front) */
14559         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14560         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14561
14562         { }
14563 };
14564
14565 static struct hda_verb alc861_threestack_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, 0x00 },
14571         /* port-B for mic-in (rear panel) with vref */
14572         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14573         /* port-C for line-in (rear panel) */
14574         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14575         /* port-D for Front */
14576         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14577         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14578         /* port-E for HP out (front panel) */
14579         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14580         /* route front PCM to HP */
14581         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14582         /* port-F for mic-in (front panel) with vref */
14583         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14584         /* port-G for CLFE (rear panel) */
14585         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14586         /* port-H for side (rear panel) */
14587         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14588         /* CD-in */
14589         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14590         /* route front mic to ADC1*/
14591         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14592         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14593         /* Unmute DAC0~3 & spdif out*/
14594         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14595         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14596         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14597         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14598         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14599
14600         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14601         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14602         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14603         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14604         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14605
14606         /* Unmute Stereo Mixer 15 */
14607         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14608         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14609         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14610         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14611
14612         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14613         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14614         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14615         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14616         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14617         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14618         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14619         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14620         /* hp used DAC 3 (Front) */
14621         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14622         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14623         { }
14624 };
14625
14626 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
14627         /*
14628          * Unmute ADC0 and set the default input to mic-in
14629          */
14630         /* port-A for surround (rear panel) */
14631         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14632         /* port-B for mic-in (rear panel) with vref */
14633         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14634         /* port-C for line-in (rear panel) */
14635         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14636         /* port-D for Front */
14637         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14638         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14639         /* port-E for HP out (front panel) */
14640         /* this has to be set to VREF80 */
14641         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14642         /* route front PCM to HP */
14643         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14644         /* port-F for mic-in (front panel) with vref */
14645         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14646         /* port-G for CLFE (rear panel) */
14647         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14648         /* port-H for side (rear panel) */
14649         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14650         /* CD-in */
14651         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14652         /* route front mic to ADC1*/
14653         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14654         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14655         /* Unmute DAC0~3 & spdif out*/
14656         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14657         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14658         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14659         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14660         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14661
14662         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14663         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14664         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14665         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14666         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14667
14668         /* Unmute Stereo Mixer 15 */
14669         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14670         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14671         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14672         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14673
14674         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14675         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14676         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14677         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14678         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14679         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14680         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14681         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14682         /* hp used DAC 3 (Front) */
14683         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14684         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14685         { }
14686 };
14687
14688 static struct hda_verb alc861_asus_init_verbs[] = {
14689         /*
14690          * Unmute ADC0 and set the default input to mic-in
14691          */
14692         /* port-A for surround (rear panel)
14693          * according to codec#0 this is the HP jack
14694          */
14695         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
14696         /* route front PCM to HP */
14697         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
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, 0x40 },
14714         /* port-H for side (rear panel) */
14715         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
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         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14728         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14729         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14730         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14731         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14732
14733         /* Unmute Stereo Mixer 15 */
14734         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14735         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14736         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14737         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14738
14739         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14740         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14741         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14742         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14743         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14744         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14745         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14746         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14747         /* hp used DAC 3 (Front) */
14748         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14749         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14750         { }
14751 };
14752
14753 /* additional init verbs for ASUS laptops */
14754 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
14755         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
14756         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
14757         { }
14758 };
14759
14760 /*
14761  * generic initialization of ADC, input mixers and output mixers
14762  */
14763 static struct hda_verb alc861_auto_init_verbs[] = {
14764         /*
14765          * Unmute ADC0 and set the default input to mic-in
14766          */
14767         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
14768         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14769
14770         /* Unmute DAC0~3 & spdif out*/
14771         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14772         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14773         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14774         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14775         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14776
14777         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14778         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14779         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14780         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14781         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14782
14783         /* Unmute Stereo Mixer 15 */
14784         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14785         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14786         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14787         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
14788
14789         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14790         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14791         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14792         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14793         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14794         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14795         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14796         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14797
14798         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14799         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14800         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14801         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14802         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14803         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14804         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14805         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14806
14807         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
14808
14809         { }
14810 };
14811
14812 static struct hda_verb alc861_toshiba_init_verbs[] = {
14813         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14814
14815         { }
14816 };
14817
14818 /* toggle speaker-output according to the hp-jack state */
14819 static void alc861_toshiba_automute(struct hda_codec *codec)
14820 {
14821         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
14822
14823         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
14824                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14825         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
14826                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
14827 }
14828
14829 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
14830                                        unsigned int res)
14831 {
14832         if ((res >> 26) == ALC880_HP_EVENT)
14833                 alc861_toshiba_automute(codec);
14834 }
14835
14836 /* pcm configuration: identical with ALC880 */
14837 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
14838 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
14839 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
14840 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
14841
14842
14843 #define ALC861_DIGOUT_NID       0x07
14844
14845 static struct hda_channel_mode alc861_8ch_modes[1] = {
14846         { 8, NULL }
14847 };
14848
14849 static hda_nid_t alc861_dac_nids[4] = {
14850         /* front, surround, clfe, side */
14851         0x03, 0x06, 0x05, 0x04
14852 };
14853
14854 static hda_nid_t alc660_dac_nids[3] = {
14855         /* front, clfe, surround */
14856         0x03, 0x05, 0x06
14857 };
14858
14859 static hda_nid_t alc861_adc_nids[1] = {
14860         /* ADC0-2 */
14861         0x08,
14862 };
14863
14864 static struct hda_input_mux alc861_capture_source = {
14865         .num_items = 5,
14866         .items = {
14867                 { "Mic", 0x0 },
14868                 { "Front Mic", 0x3 },
14869                 { "Line", 0x1 },
14870                 { "CD", 0x4 },
14871                 { "Mixer", 0x5 },
14872         },
14873 };
14874
14875 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
14876 {
14877         struct alc_spec *spec = codec->spec;
14878         hda_nid_t mix, srcs[5];
14879         int i, j, num;
14880
14881         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
14882                 return 0;
14883         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14884         if (num < 0)
14885                 return 0;
14886         for (i = 0; i < num; i++) {
14887                 unsigned int type;
14888                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
14889                 if (type != AC_WID_AUD_OUT)
14890                         continue;
14891                 for (j = 0; j < spec->multiout.num_dacs; j++)
14892                         if (spec->multiout.dac_nids[j] == srcs[i])
14893                                 break;
14894                 if (j >= spec->multiout.num_dacs)
14895                         return srcs[i];
14896         }
14897         return 0;
14898 }
14899
14900 /* fill in the dac_nids table from the parsed pin configuration */
14901 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
14902                                      const struct auto_pin_cfg *cfg)
14903 {
14904         struct alc_spec *spec = codec->spec;
14905         int i;
14906         hda_nid_t nid, dac;
14907
14908         spec->multiout.dac_nids = spec->private_dac_nids;
14909         for (i = 0; i < cfg->line_outs; i++) {
14910                 nid = cfg->line_out_pins[i];
14911                 dac = alc861_look_for_dac(codec, nid);
14912                 if (!dac)
14913                         continue;
14914                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
14915         }
14916         return 0;
14917 }
14918
14919 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
14920                                 hda_nid_t nid, unsigned int chs)
14921 {
14922         return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
14923                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
14924 }
14925
14926 /* add playback controls from the parsed DAC table */
14927 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
14928                                              const struct auto_pin_cfg *cfg)
14929 {
14930         struct alc_spec *spec = codec->spec;
14931         static const char *chname[4] = {
14932                 "Front", "Surround", NULL /*CLFE*/, "Side"
14933         };
14934         hda_nid_t nid;
14935         int i, err;
14936
14937         if (cfg->line_outs == 1) {
14938                 const char *pfx = NULL;
14939                 if (!cfg->hp_outs)
14940                         pfx = "Master";
14941                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
14942                         pfx = "Speaker";
14943                 if (pfx) {
14944                         nid = spec->multiout.dac_nids[0];
14945                         return alc861_create_out_sw(codec, pfx, nid, 3);
14946                 }
14947         }
14948
14949         for (i = 0; i < cfg->line_outs; i++) {
14950                 nid = spec->multiout.dac_nids[i];
14951                 if (!nid)
14952                         continue;
14953                 if (i == 2) {
14954                         /* Center/LFE */
14955                         err = alc861_create_out_sw(codec, "Center", nid, 1);
14956                         if (err < 0)
14957                                 return err;
14958                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
14959                         if (err < 0)
14960                                 return err;
14961                 } else {
14962                         err = alc861_create_out_sw(codec, chname[i], nid, 3);
14963                         if (err < 0)
14964                                 return err;
14965                 }
14966         }
14967         return 0;
14968 }
14969
14970 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
14971 {
14972         struct alc_spec *spec = codec->spec;
14973         int err;
14974         hda_nid_t nid;
14975
14976         if (!pin)
14977                 return 0;
14978
14979         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
14980                 nid = alc861_look_for_dac(codec, pin);
14981                 if (nid) {
14982                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
14983                         if (err < 0)
14984                                 return err;
14985                         spec->multiout.hp_nid = nid;
14986                 }
14987         }
14988         return 0;
14989 }
14990
14991 /* create playback/capture controls for input pins */
14992 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
14993                                                 const struct auto_pin_cfg *cfg)
14994 {
14995         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
14996 }
14997
14998 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
14999                                               hda_nid_t nid,
15000                                               int pin_type, hda_nid_t dac)
15001 {
15002         hda_nid_t mix, srcs[5];
15003         int i, num;
15004
15005         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
15006                             pin_type);
15007         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15008                             AMP_OUT_UNMUTE);
15009         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
15010                 return;
15011         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15012         if (num < 0)
15013                 return;
15014         for (i = 0; i < num; i++) {
15015                 unsigned int mute;
15016                 if (srcs[i] == dac || srcs[i] == 0x15)
15017                         mute = AMP_IN_UNMUTE(i);
15018                 else
15019                         mute = AMP_IN_MUTE(i);
15020                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15021                                     mute);
15022         }
15023 }
15024
15025 static void alc861_auto_init_multi_out(struct hda_codec *codec)
15026 {
15027         struct alc_spec *spec = codec->spec;
15028         int i;
15029
15030         for (i = 0; i < spec->autocfg.line_outs; i++) {
15031                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
15032                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
15033                 if (nid)
15034                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
15035                                                           spec->multiout.dac_nids[i]);
15036         }
15037 }
15038
15039 static void alc861_auto_init_hp_out(struct hda_codec *codec)
15040 {
15041         struct alc_spec *spec = codec->spec;
15042
15043         if (spec->autocfg.hp_outs)
15044                 alc861_auto_set_output_and_unmute(codec,
15045                                                   spec->autocfg.hp_pins[0],
15046                                                   PIN_HP,
15047                                                   spec->multiout.hp_nid);
15048         if (spec->autocfg.speaker_outs)
15049                 alc861_auto_set_output_and_unmute(codec,
15050                                                   spec->autocfg.speaker_pins[0],
15051                                                   PIN_OUT,
15052                                                   spec->multiout.dac_nids[0]);
15053 }
15054
15055 static void alc861_auto_init_analog_input(struct hda_codec *codec)
15056 {
15057         struct alc_spec *spec = codec->spec;
15058         int i;
15059
15060         for (i = 0; i < AUTO_PIN_LAST; i++) {
15061                 hda_nid_t nid = spec->autocfg.input_pins[i];
15062                 if (nid >= 0x0c && nid <= 0x11)
15063                         alc_set_input_pin(codec, nid, i);
15064         }
15065 }
15066
15067 /* parse the BIOS configuration and set up the alc_spec */
15068 /* return 1 if successful, 0 if the proper config is not found,
15069  * or a negative error code
15070  */
15071 static int alc861_parse_auto_config(struct hda_codec *codec)
15072 {
15073         struct alc_spec *spec = codec->spec;
15074         int err;
15075         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
15076
15077         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15078                                            alc861_ignore);
15079         if (err < 0)
15080                 return err;
15081         if (!spec->autocfg.line_outs)
15082                 return 0; /* can't find valid BIOS pin config */
15083
15084         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
15085         if (err < 0)
15086                 return err;
15087         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
15088         if (err < 0)
15089                 return err;
15090         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
15091         if (err < 0)
15092                 return err;
15093         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
15094         if (err < 0)
15095                 return err;
15096
15097         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15098
15099         if (spec->autocfg.dig_outs)
15100                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
15101
15102         if (spec->kctls.list)
15103                 add_mixer(spec, spec->kctls.list);
15104
15105         add_verb(spec, alc861_auto_init_verbs);
15106
15107         spec->num_mux_defs = 1;
15108         spec->input_mux = &spec->private_imux[0];
15109
15110         spec->adc_nids = alc861_adc_nids;
15111         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
15112         set_capture_mixer(codec);
15113
15114         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
15115
15116         return 1;
15117 }
15118
15119 /* additional initialization for auto-configuration model */
15120 static void alc861_auto_init(struct hda_codec *codec)
15121 {
15122         struct alc_spec *spec = codec->spec;
15123         alc861_auto_init_multi_out(codec);
15124         alc861_auto_init_hp_out(codec);
15125         alc861_auto_init_analog_input(codec);
15126         if (spec->unsol_event)
15127                 alc_inithook(codec);
15128 }
15129
15130 #ifdef CONFIG_SND_HDA_POWER_SAVE
15131 static struct hda_amp_list alc861_loopbacks[] = {
15132         { 0x15, HDA_INPUT, 0 },
15133         { 0x15, HDA_INPUT, 1 },
15134         { 0x15, HDA_INPUT, 2 },
15135         { 0x15, HDA_INPUT, 3 },
15136         { } /* end */
15137 };
15138 #endif
15139
15140
15141 /*
15142  * configuration and preset
15143  */
15144 static const char *alc861_models[ALC861_MODEL_LAST] = {
15145         [ALC861_3ST]            = "3stack",
15146         [ALC660_3ST]            = "3stack-660",
15147         [ALC861_3ST_DIG]        = "3stack-dig",
15148         [ALC861_6ST_DIG]        = "6stack-dig",
15149         [ALC861_UNIWILL_M31]    = "uniwill-m31",
15150         [ALC861_TOSHIBA]        = "toshiba",
15151         [ALC861_ASUS]           = "asus",
15152         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
15153         [ALC861_AUTO]           = "auto",
15154 };
15155
15156 static struct snd_pci_quirk alc861_cfg_tbl[] = {
15157         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
15158         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
15159         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
15160         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
15161         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
15162         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
15163         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
15164         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
15165          *        Any other models that need this preset?
15166          */
15167         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
15168         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
15169         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
15170         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
15171         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
15172         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
15173         /* FIXME: the below seems conflict */
15174         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
15175         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
15176         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
15177         {}
15178 };
15179
15180 static struct alc_config_preset alc861_presets[] = {
15181         [ALC861_3ST] = {
15182                 .mixers = { alc861_3ST_mixer },
15183                 .init_verbs = { alc861_threestack_init_verbs },
15184                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15185                 .dac_nids = alc861_dac_nids,
15186                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15187                 .channel_mode = alc861_threestack_modes,
15188                 .need_dac_fix = 1,
15189                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15190                 .adc_nids = alc861_adc_nids,
15191                 .input_mux = &alc861_capture_source,
15192         },
15193         [ALC861_3ST_DIG] = {
15194                 .mixers = { alc861_base_mixer },
15195                 .init_verbs = { alc861_threestack_init_verbs },
15196                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15197                 .dac_nids = alc861_dac_nids,
15198                 .dig_out_nid = ALC861_DIGOUT_NID,
15199                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15200                 .channel_mode = alc861_threestack_modes,
15201                 .need_dac_fix = 1,
15202                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15203                 .adc_nids = alc861_adc_nids,
15204                 .input_mux = &alc861_capture_source,
15205         },
15206         [ALC861_6ST_DIG] = {
15207                 .mixers = { alc861_base_mixer },
15208                 .init_verbs = { alc861_base_init_verbs },
15209                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15210                 .dac_nids = alc861_dac_nids,
15211                 .dig_out_nid = ALC861_DIGOUT_NID,
15212                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
15213                 .channel_mode = alc861_8ch_modes,
15214                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15215                 .adc_nids = alc861_adc_nids,
15216                 .input_mux = &alc861_capture_source,
15217         },
15218         [ALC660_3ST] = {
15219                 .mixers = { alc861_3ST_mixer },
15220                 .init_verbs = { alc861_threestack_init_verbs },
15221                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
15222                 .dac_nids = alc660_dac_nids,
15223                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15224                 .channel_mode = alc861_threestack_modes,
15225                 .need_dac_fix = 1,
15226                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15227                 .adc_nids = alc861_adc_nids,
15228                 .input_mux = &alc861_capture_source,
15229         },
15230         [ALC861_UNIWILL_M31] = {
15231                 .mixers = { alc861_uniwill_m31_mixer },
15232                 .init_verbs = { alc861_uniwill_m31_init_verbs },
15233                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15234                 .dac_nids = alc861_dac_nids,
15235                 .dig_out_nid = ALC861_DIGOUT_NID,
15236                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
15237                 .channel_mode = alc861_uniwill_m31_modes,
15238                 .need_dac_fix = 1,
15239                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15240                 .adc_nids = alc861_adc_nids,
15241                 .input_mux = &alc861_capture_source,
15242         },
15243         [ALC861_TOSHIBA] = {
15244                 .mixers = { alc861_toshiba_mixer },
15245                 .init_verbs = { alc861_base_init_verbs,
15246                                 alc861_toshiba_init_verbs },
15247                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15248                 .dac_nids = alc861_dac_nids,
15249                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
15250                 .channel_mode = alc883_3ST_2ch_modes,
15251                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15252                 .adc_nids = alc861_adc_nids,
15253                 .input_mux = &alc861_capture_source,
15254                 .unsol_event = alc861_toshiba_unsol_event,
15255                 .init_hook = alc861_toshiba_automute,
15256         },
15257         [ALC861_ASUS] = {
15258                 .mixers = { alc861_asus_mixer },
15259                 .init_verbs = { alc861_asus_init_verbs },
15260                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15261                 .dac_nids = alc861_dac_nids,
15262                 .dig_out_nid = ALC861_DIGOUT_NID,
15263                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
15264                 .channel_mode = alc861_asus_modes,
15265                 .need_dac_fix = 1,
15266                 .hp_nid = 0x06,
15267                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15268                 .adc_nids = alc861_adc_nids,
15269                 .input_mux = &alc861_capture_source,
15270         },
15271         [ALC861_ASUS_LAPTOP] = {
15272                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
15273                 .init_verbs = { alc861_asus_init_verbs,
15274                                 alc861_asus_laptop_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(alc883_3ST_2ch_modes),
15279                 .channel_mode = alc883_3ST_2ch_modes,
15280                 .need_dac_fix = 1,
15281                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15282                 .adc_nids = alc861_adc_nids,
15283                 .input_mux = &alc861_capture_source,
15284         },
15285 };
15286
15287 /* Pin config fixes */
15288 enum {
15289         PINFIX_FSC_AMILO_PI1505,
15290 };
15291
15292 static struct alc_pincfg alc861_fsc_amilo_pi1505_pinfix[] = {
15293         { 0x0b, 0x0221101f }, /* HP */
15294         { 0x0f, 0x90170310 }, /* speaker */
15295         { }
15296 };
15297
15298 static const struct alc_fixup alc861_fixups[] = {
15299         [PINFIX_FSC_AMILO_PI1505] = {
15300                 .pins = alc861_fsc_amilo_pi1505_pinfix
15301         },
15302 };
15303
15304 static struct snd_pci_quirk alc861_fixup_tbl[] = {
15305         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
15306         {}
15307 };
15308
15309 static int patch_alc861(struct hda_codec *codec)
15310 {
15311         struct alc_spec *spec;
15312         int board_config;
15313         int err;
15314
15315         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15316         if (spec == NULL)
15317                 return -ENOMEM;
15318
15319         codec->spec = spec;
15320
15321         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
15322                                                   alc861_models,
15323                                                   alc861_cfg_tbl);
15324
15325         if (board_config < 0) {
15326                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15327                        codec->chip_name);
15328                 board_config = ALC861_AUTO;
15329         }
15330
15331         alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups);
15332
15333         if (board_config == ALC861_AUTO) {
15334                 /* automatic parse from the BIOS config */
15335                 err = alc861_parse_auto_config(codec);
15336                 if (err < 0) {
15337                         alc_free(codec);
15338                         return err;
15339                 } else if (!err) {
15340                         printk(KERN_INFO
15341                                "hda_codec: Cannot set up configuration "
15342                                "from BIOS.  Using base mode...\n");
15343                    board_config = ALC861_3ST_DIG;
15344                 }
15345         }
15346
15347         err = snd_hda_attach_beep_device(codec, 0x23);
15348         if (err < 0) {
15349                 alc_free(codec);
15350                 return err;
15351         }
15352
15353         if (board_config != ALC861_AUTO)
15354                 setup_preset(codec, &alc861_presets[board_config]);
15355
15356         spec->stream_analog_playback = &alc861_pcm_analog_playback;
15357         spec->stream_analog_capture = &alc861_pcm_analog_capture;
15358
15359         spec->stream_digital_playback = &alc861_pcm_digital_playback;
15360         spec->stream_digital_capture = &alc861_pcm_digital_capture;
15361
15362         if (!spec->cap_mixer)
15363                 set_capture_mixer(codec);
15364         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
15365
15366         spec->vmaster_nid = 0x03;
15367
15368         codec->patch_ops = alc_patch_ops;
15369         if (board_config == ALC861_AUTO) {
15370                 spec->init_hook = alc861_auto_init;
15371 #ifdef CONFIG_SND_HDA_POWER_SAVE
15372                 spec->power_hook = alc_power_eapd;
15373 #endif
15374         }
15375 #ifdef CONFIG_SND_HDA_POWER_SAVE
15376         if (!spec->loopback.amplist)
15377                 spec->loopback.amplist = alc861_loopbacks;
15378 #endif
15379
15380         return 0;
15381 }
15382
15383 /*
15384  * ALC861-VD support
15385  *
15386  * Based on ALC882
15387  *
15388  * In addition, an independent DAC
15389  */
15390 #define ALC861VD_DIGOUT_NID     0x06
15391
15392 static hda_nid_t alc861vd_dac_nids[4] = {
15393         /* front, surr, clfe, side surr */
15394         0x02, 0x03, 0x04, 0x05
15395 };
15396
15397 /* dac_nids for ALC660vd are in a different order - according to
15398  * Realtek's driver.
15399  * This should probably result in a different mixer for 6stack models
15400  * of ALC660vd codecs, but for now there is only 3stack mixer
15401  * - and it is the same as in 861vd.
15402  * adc_nids in ALC660vd are (is) the same as in 861vd
15403  */
15404 static hda_nid_t alc660vd_dac_nids[3] = {
15405         /* front, rear, clfe, rear_surr */
15406         0x02, 0x04, 0x03
15407 };
15408
15409 static hda_nid_t alc861vd_adc_nids[1] = {
15410         /* ADC0 */
15411         0x09,
15412 };
15413
15414 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
15415
15416 /* input MUX */
15417 /* FIXME: should be a matrix-type input source selection */
15418 static struct hda_input_mux alc861vd_capture_source = {
15419         .num_items = 4,
15420         .items = {
15421                 { "Mic", 0x0 },
15422                 { "Front Mic", 0x1 },
15423                 { "Line", 0x2 },
15424                 { "CD", 0x4 },
15425         },
15426 };
15427
15428 static struct hda_input_mux alc861vd_dallas_capture_source = {
15429         .num_items = 2,
15430         .items = {
15431                 { "Ext Mic", 0x0 },
15432                 { "Int Mic", 0x1 },
15433         },
15434 };
15435
15436 static struct hda_input_mux alc861vd_hp_capture_source = {
15437         .num_items = 2,
15438         .items = {
15439                 { "Front Mic", 0x0 },
15440                 { "ATAPI Mic", 0x1 },
15441         },
15442 };
15443
15444 /*
15445  * 2ch mode
15446  */
15447 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
15448         { 2, NULL }
15449 };
15450
15451 /*
15452  * 6ch mode
15453  */
15454 static struct hda_verb alc861vd_6stack_ch6_init[] = {
15455         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15456         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15457         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15458         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15459         { } /* end */
15460 };
15461
15462 /*
15463  * 8ch mode
15464  */
15465 static struct hda_verb alc861vd_6stack_ch8_init[] = {
15466         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15467         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15468         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15469         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15470         { } /* end */
15471 };
15472
15473 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
15474         { 6, alc861vd_6stack_ch6_init },
15475         { 8, alc861vd_6stack_ch8_init },
15476 };
15477
15478 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
15479         {
15480                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15481                 .name = "Channel Mode",
15482                 .info = alc_ch_mode_info,
15483                 .get = alc_ch_mode_get,
15484                 .put = alc_ch_mode_put,
15485         },
15486         { } /* end */
15487 };
15488
15489 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15490  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15491  */
15492 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
15493         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15494         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15495
15496         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15497         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
15498
15499         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
15500                                 HDA_OUTPUT),
15501         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
15502                                 HDA_OUTPUT),
15503         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
15504         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
15505
15506         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
15507         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
15508
15509         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15510
15511         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15512         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15513         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15514
15515         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15516         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15517         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15518
15519         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15520         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15521
15522         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15523         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15524
15525         { } /* end */
15526 };
15527
15528 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
15529         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15530         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15531
15532         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15533
15534         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15535         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15536         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15537
15538         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15539         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15540         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15541
15542         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15543         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15544
15545         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15546         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15547
15548         { } /* end */
15549 };
15550
15551 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
15552         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15553         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
15554         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15555
15556         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15557
15558         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15559         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15560         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15561
15562         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15563         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15564         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15565
15566         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15567         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15568
15569         { } /* end */
15570 };
15571
15572 /* Pin assignment: Speaker=0x14, HP = 0x15,
15573  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
15574  */
15575 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
15576         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15577         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
15578         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15579         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15580         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
15581         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15582         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15583         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
15584         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15585         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15586         { } /* end */
15587 };
15588
15589 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
15590  *                 Front Mic=0x18, ATAPI Mic = 0x19,
15591  */
15592 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
15593         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15594         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15595         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15596         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15597         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15598         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15599         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15600         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15601
15602         { } /* end */
15603 };
15604
15605 /*
15606  * generic initialization of ADC, input mixers and output mixers
15607  */
15608 static struct hda_verb alc861vd_volume_init_verbs[] = {
15609         /*
15610          * Unmute ADC0 and set the default input to mic-in
15611          */
15612         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15613         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15614
15615         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
15616          * the analog-loopback mixer widget
15617          */
15618         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15619         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15620         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15621         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15622         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15623         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15624
15625         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
15626         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15627         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15628         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15629         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15630
15631         /*
15632          * Set up output mixers (0x02 - 0x05)
15633          */
15634         /* set vol=0 to output mixers */
15635         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15636         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15637         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15638         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15639
15640         /* set up input amps for analog loopback */
15641         /* Amp Indices: DAC = 0, mixer = 1 */
15642         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15643         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15644         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15645         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15646         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15647         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15648         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15649         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15650
15651         { }
15652 };
15653
15654 /*
15655  * 3-stack pin configuration:
15656  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
15657  */
15658 static struct hda_verb alc861vd_3stack_init_verbs[] = {
15659         /*
15660          * Set pin mode and muting
15661          */
15662         /* set front pin widgets 0x14 for output */
15663         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15664         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15665         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15666
15667         /* Mic (rear) pin: input vref at 80% */
15668         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15669         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15670         /* Front Mic pin: input vref at 80% */
15671         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15672         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15673         /* Line In pin: input */
15674         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15675         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15676         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15677         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15678         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15679         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15680         /* CD pin widget for input */
15681         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15682
15683         { }
15684 };
15685
15686 /*
15687  * 6-stack pin configuration:
15688  */
15689 static struct hda_verb alc861vd_6stack_init_verbs[] = {
15690         /*
15691          * Set pin mode and muting
15692          */
15693         /* set front pin widgets 0x14 for output */
15694         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15695         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15696         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15697
15698         /* Rear Pin: output 1 (0x0d) */
15699         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15700         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15701         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
15702         /* CLFE Pin: output 2 (0x0e) */
15703         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15704         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15705         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
15706         /* Side Pin: output 3 (0x0f) */
15707         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15708         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15709         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
15710
15711         /* Mic (rear) pin: input vref at 80% */
15712         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15713         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15714         /* Front Mic pin: input vref at 80% */
15715         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15716         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15717         /* Line In pin: input */
15718         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15719         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15720         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15721         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15722         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15723         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15724         /* CD pin widget for input */
15725         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15726
15727         { }
15728 };
15729
15730 static struct hda_verb alc861vd_eapd_verbs[] = {
15731         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15732         { }
15733 };
15734
15735 static struct hda_verb alc660vd_eapd_verbs[] = {
15736         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15737         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15738         { }
15739 };
15740
15741 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
15742         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15743         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15744         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
15745         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15746         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15747         {}
15748 };
15749
15750 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
15751 {
15752         unsigned int present;
15753         unsigned char bits;
15754
15755         present = snd_hda_jack_detect(codec, 0x18);
15756         bits = present ? HDA_AMP_MUTE : 0;
15757
15758         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
15759                                  HDA_AMP_MUTE, bits);
15760 }
15761
15762 static void alc861vd_lenovo_setup(struct hda_codec *codec)
15763 {
15764         struct alc_spec *spec = codec->spec;
15765         spec->autocfg.hp_pins[0] = 0x1b;
15766         spec->autocfg.speaker_pins[0] = 0x14;
15767 }
15768
15769 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
15770 {
15771         alc_automute_amp(codec);
15772         alc861vd_lenovo_mic_automute(codec);
15773 }
15774
15775 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
15776                                         unsigned int res)
15777 {
15778         switch (res >> 26) {
15779         case ALC880_MIC_EVENT:
15780                 alc861vd_lenovo_mic_automute(codec);
15781                 break;
15782         default:
15783                 alc_automute_amp_unsol_event(codec, res);
15784                 break;
15785         }
15786 }
15787
15788 static struct hda_verb alc861vd_dallas_verbs[] = {
15789         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15790         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15791         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15792         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15793
15794         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15795         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15796         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15797         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15798         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15799         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15800         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15801         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15802
15803         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15804         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15805         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15806         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15807         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15808         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15809         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15810         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15811
15812         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15813         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15814         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15815         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15816         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15817         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15818         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15819         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15820
15821         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15822         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15823         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15824         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15825
15826         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15827         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15828         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15829
15830         { } /* end */
15831 };
15832
15833 /* toggle speaker-output according to the hp-jack state */
15834 static void alc861vd_dallas_setup(struct hda_codec *codec)
15835 {
15836         struct alc_spec *spec = codec->spec;
15837
15838         spec->autocfg.hp_pins[0] = 0x15;
15839         spec->autocfg.speaker_pins[0] = 0x14;
15840 }
15841
15842 #ifdef CONFIG_SND_HDA_POWER_SAVE
15843 #define alc861vd_loopbacks      alc880_loopbacks
15844 #endif
15845
15846 /* pcm configuration: identical with ALC880 */
15847 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
15848 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
15849 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
15850 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
15851
15852 /*
15853  * configuration and preset
15854  */
15855 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
15856         [ALC660VD_3ST]          = "3stack-660",
15857         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
15858         [ALC660VD_ASUS_V1S]     = "asus-v1s",
15859         [ALC861VD_3ST]          = "3stack",
15860         [ALC861VD_3ST_DIG]      = "3stack-digout",
15861         [ALC861VD_6ST_DIG]      = "6stack-digout",
15862         [ALC861VD_LENOVO]       = "lenovo",
15863         [ALC861VD_DALLAS]       = "dallas",
15864         [ALC861VD_HP]           = "hp",
15865         [ALC861VD_AUTO]         = "auto",
15866 };
15867
15868 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
15869         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
15870         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
15871         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
15872         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
15873         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
15874         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
15875         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
15876         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
15877         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
15878         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
15879         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
15880         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
15881         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
15882         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
15883         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
15884         {}
15885 };
15886
15887 static struct alc_config_preset alc861vd_presets[] = {
15888         [ALC660VD_3ST] = {
15889                 .mixers = { alc861vd_3st_mixer },
15890                 .init_verbs = { alc861vd_volume_init_verbs,
15891                                  alc861vd_3stack_init_verbs },
15892                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15893                 .dac_nids = alc660vd_dac_nids,
15894                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15895                 .channel_mode = alc861vd_3stack_2ch_modes,
15896                 .input_mux = &alc861vd_capture_source,
15897         },
15898         [ALC660VD_3ST_DIG] = {
15899                 .mixers = { alc861vd_3st_mixer },
15900                 .init_verbs = { alc861vd_volume_init_verbs,
15901                                  alc861vd_3stack_init_verbs },
15902                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15903                 .dac_nids = alc660vd_dac_nids,
15904                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15905                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15906                 .channel_mode = alc861vd_3stack_2ch_modes,
15907                 .input_mux = &alc861vd_capture_source,
15908         },
15909         [ALC861VD_3ST] = {
15910                 .mixers = { alc861vd_3st_mixer },
15911                 .init_verbs = { alc861vd_volume_init_verbs,
15912                                  alc861vd_3stack_init_verbs },
15913                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15914                 .dac_nids = alc861vd_dac_nids,
15915                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15916                 .channel_mode = alc861vd_3stack_2ch_modes,
15917                 .input_mux = &alc861vd_capture_source,
15918         },
15919         [ALC861VD_3ST_DIG] = {
15920                 .mixers = { alc861vd_3st_mixer },
15921                 .init_verbs = { alc861vd_volume_init_verbs,
15922                                  alc861vd_3stack_init_verbs },
15923                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15924                 .dac_nids = alc861vd_dac_nids,
15925                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15926                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15927                 .channel_mode = alc861vd_3stack_2ch_modes,
15928                 .input_mux = &alc861vd_capture_source,
15929         },
15930         [ALC861VD_6ST_DIG] = {
15931                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
15932                 .init_verbs = { alc861vd_volume_init_verbs,
15933                                 alc861vd_6stack_init_verbs },
15934                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15935                 .dac_nids = alc861vd_dac_nids,
15936                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15937                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
15938                 .channel_mode = alc861vd_6stack_modes,
15939                 .input_mux = &alc861vd_capture_source,
15940         },
15941         [ALC861VD_LENOVO] = {
15942                 .mixers = { alc861vd_lenovo_mixer },
15943                 .init_verbs = { alc861vd_volume_init_verbs,
15944                                 alc861vd_3stack_init_verbs,
15945                                 alc861vd_eapd_verbs,
15946                                 alc861vd_lenovo_unsol_verbs },
15947                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15948                 .dac_nids = alc660vd_dac_nids,
15949                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15950                 .channel_mode = alc861vd_3stack_2ch_modes,
15951                 .input_mux = &alc861vd_capture_source,
15952                 .unsol_event = alc861vd_lenovo_unsol_event,
15953                 .setup = alc861vd_lenovo_setup,
15954                 .init_hook = alc861vd_lenovo_init_hook,
15955         },
15956         [ALC861VD_DALLAS] = {
15957                 .mixers = { alc861vd_dallas_mixer },
15958                 .init_verbs = { alc861vd_dallas_verbs },
15959                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15960                 .dac_nids = alc861vd_dac_nids,
15961                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15962                 .channel_mode = alc861vd_3stack_2ch_modes,
15963                 .input_mux = &alc861vd_dallas_capture_source,
15964                 .unsol_event = alc_automute_amp_unsol_event,
15965                 .setup = alc861vd_dallas_setup,
15966                 .init_hook = alc_automute_amp,
15967         },
15968         [ALC861VD_HP] = {
15969                 .mixers = { alc861vd_hp_mixer },
15970                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
15971                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15972                 .dac_nids = alc861vd_dac_nids,
15973                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15974                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15975                 .channel_mode = alc861vd_3stack_2ch_modes,
15976                 .input_mux = &alc861vd_hp_capture_source,
15977                 .unsol_event = alc_automute_amp_unsol_event,
15978                 .setup = alc861vd_dallas_setup,
15979                 .init_hook = alc_automute_amp,
15980         },
15981         [ALC660VD_ASUS_V1S] = {
15982                 .mixers = { alc861vd_lenovo_mixer },
15983                 .init_verbs = { alc861vd_volume_init_verbs,
15984                                 alc861vd_3stack_init_verbs,
15985                                 alc861vd_eapd_verbs,
15986                                 alc861vd_lenovo_unsol_verbs },
15987                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15988                 .dac_nids = alc660vd_dac_nids,
15989                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15990                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15991                 .channel_mode = alc861vd_3stack_2ch_modes,
15992                 .input_mux = &alc861vd_capture_source,
15993                 .unsol_event = alc861vd_lenovo_unsol_event,
15994                 .setup = alc861vd_lenovo_setup,
15995                 .init_hook = alc861vd_lenovo_init_hook,
15996         },
15997 };
15998
15999 /*
16000  * BIOS auto configuration
16001  */
16002 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
16003                                                 const struct auto_pin_cfg *cfg)
16004 {
16005         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x09, 0);
16006 }
16007
16008
16009 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
16010                                 hda_nid_t nid, int pin_type, int dac_idx)
16011 {
16012         alc_set_pin_output(codec, nid, pin_type);
16013 }
16014
16015 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
16016 {
16017         struct alc_spec *spec = codec->spec;
16018         int i;
16019
16020         for (i = 0; i <= HDA_SIDE; i++) {
16021                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16022                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16023                 if (nid)
16024                         alc861vd_auto_set_output_and_unmute(codec, nid,
16025                                                             pin_type, i);
16026         }
16027 }
16028
16029
16030 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
16031 {
16032         struct alc_spec *spec = codec->spec;
16033         hda_nid_t pin;
16034
16035         pin = spec->autocfg.hp_pins[0];
16036         if (pin) /* connect to front and use dac 0 */
16037                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16038         pin = spec->autocfg.speaker_pins[0];
16039         if (pin)
16040                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16041 }
16042
16043 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
16044
16045 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
16046 {
16047         struct alc_spec *spec = codec->spec;
16048         int i;
16049
16050         for (i = 0; i < AUTO_PIN_LAST; i++) {
16051                 hda_nid_t nid = spec->autocfg.input_pins[i];
16052                 if (alc_is_input_pin(codec, nid)) {
16053                         alc_set_input_pin(codec, nid, i);
16054                         if (nid != ALC861VD_PIN_CD_NID &&
16055                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16056                                 snd_hda_codec_write(codec, nid, 0,
16057                                                 AC_VERB_SET_AMP_GAIN_MUTE,
16058                                                 AMP_OUT_MUTE);
16059                 }
16060         }
16061 }
16062
16063 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
16064
16065 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
16066 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
16067
16068 /* add playback controls from the parsed DAC table */
16069 /* Based on ALC880 version. But ALC861VD has separate,
16070  * different NIDs for mute/unmute switch and volume control */
16071 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
16072                                              const struct auto_pin_cfg *cfg)
16073 {
16074         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
16075         hda_nid_t nid_v, nid_s;
16076         int i, err;
16077
16078         for (i = 0; i < cfg->line_outs; i++) {
16079                 if (!spec->multiout.dac_nids[i])
16080                         continue;
16081                 nid_v = alc861vd_idx_to_mixer_vol(
16082                                 alc880_dac_to_idx(
16083                                         spec->multiout.dac_nids[i]));
16084                 nid_s = alc861vd_idx_to_mixer_switch(
16085                                 alc880_dac_to_idx(
16086                                         spec->multiout.dac_nids[i]));
16087
16088                 if (i == 2) {
16089                         /* Center/LFE */
16090                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
16091                                               "Center",
16092                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
16093                                                               HDA_OUTPUT));
16094                         if (err < 0)
16095                                 return err;
16096                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
16097                                               "LFE",
16098                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
16099                                                               HDA_OUTPUT));
16100                         if (err < 0)
16101                                 return err;
16102                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
16103                                              "Center",
16104                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
16105                                                               HDA_INPUT));
16106                         if (err < 0)
16107                                 return err;
16108                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
16109                                              "LFE",
16110                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
16111                                                               HDA_INPUT));
16112                         if (err < 0)
16113                                 return err;
16114                 } else {
16115                         const char *pfx;
16116                         if (cfg->line_outs == 1 &&
16117                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
16118                                 if (!cfg->hp_pins)
16119                                         pfx = "Speaker";
16120                                 else
16121                                         pfx = "PCM";
16122                         } else
16123                                 pfx = chname[i];
16124                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
16125                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
16126                                                               HDA_OUTPUT));
16127                         if (err < 0)
16128                                 return err;
16129                         if (cfg->line_outs == 1 &&
16130                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
16131                                 pfx = "Speaker";
16132                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
16133                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
16134                                                               HDA_INPUT));
16135                         if (err < 0)
16136                                 return err;
16137                 }
16138         }
16139         return 0;
16140 }
16141
16142 /* add playback controls for speaker and HP outputs */
16143 /* Based on ALC880 version. But ALC861VD has separate,
16144  * different NIDs for mute/unmute switch and volume control */
16145 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
16146                                         hda_nid_t pin, const char *pfx)
16147 {
16148         hda_nid_t nid_v, nid_s;
16149         int err;
16150
16151         if (!pin)
16152                 return 0;
16153
16154         if (alc880_is_fixed_pin(pin)) {
16155                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16156                 /* specify the DAC as the extra output */
16157                 if (!spec->multiout.hp_nid)
16158                         spec->multiout.hp_nid = nid_v;
16159                 else
16160                         spec->multiout.extra_out_nid[0] = nid_v;
16161                 /* control HP volume/switch on the output mixer amp */
16162                 nid_v = alc861vd_idx_to_mixer_vol(
16163                                 alc880_fixed_pin_idx(pin));
16164                 nid_s = alc861vd_idx_to_mixer_switch(
16165                                 alc880_fixed_pin_idx(pin));
16166
16167                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
16168                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
16169                 if (err < 0)
16170                         return err;
16171                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
16172                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
16173                 if (err < 0)
16174                         return err;
16175         } else if (alc880_is_multi_pin(pin)) {
16176                 /* set manual connection */
16177                 /* we have only a switch on HP-out PIN */
16178                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
16179                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16180                 if (err < 0)
16181                         return err;
16182         }
16183         return 0;
16184 }
16185
16186 /* parse the BIOS configuration and set up the alc_spec
16187  * return 1 if successful, 0 if the proper config is not found,
16188  * or a negative error code
16189  * Based on ALC880 version - had to change it to override
16190  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
16191 static int alc861vd_parse_auto_config(struct hda_codec *codec)
16192 {
16193         struct alc_spec *spec = codec->spec;
16194         int err;
16195         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
16196
16197         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16198                                            alc861vd_ignore);
16199         if (err < 0)
16200                 return err;
16201         if (!spec->autocfg.line_outs)
16202                 return 0; /* can't find valid BIOS pin config */
16203
16204         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16205         if (err < 0)
16206                 return err;
16207         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
16208         if (err < 0)
16209                 return err;
16210         err = alc861vd_auto_create_extra_out(spec,
16211                                              spec->autocfg.speaker_pins[0],
16212                                              "Speaker");
16213         if (err < 0)
16214                 return err;
16215         err = alc861vd_auto_create_extra_out(spec,
16216                                              spec->autocfg.hp_pins[0],
16217                                              "Headphone");
16218         if (err < 0)
16219                 return err;
16220         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
16221         if (err < 0)
16222                 return err;
16223
16224         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16225
16226         if (spec->autocfg.dig_outs)
16227                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
16228
16229         if (spec->kctls.list)
16230                 add_mixer(spec, spec->kctls.list);
16231
16232         add_verb(spec, alc861vd_volume_init_verbs);
16233
16234         spec->num_mux_defs = 1;
16235         spec->input_mux = &spec->private_imux[0];
16236
16237         err = alc_auto_add_mic_boost(codec);
16238         if (err < 0)
16239                 return err;
16240
16241         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
16242
16243         return 1;
16244 }
16245
16246 /* additional initialization for auto-configuration model */
16247 static void alc861vd_auto_init(struct hda_codec *codec)
16248 {
16249         struct alc_spec *spec = codec->spec;
16250         alc861vd_auto_init_multi_out(codec);
16251         alc861vd_auto_init_hp_out(codec);
16252         alc861vd_auto_init_analog_input(codec);
16253         alc861vd_auto_init_input_src(codec);
16254         if (spec->unsol_event)
16255                 alc_inithook(codec);
16256 }
16257
16258 enum {
16259         ALC660VD_FIX_ASUS_GPIO1
16260 };
16261
16262 /* reset GPIO1 */
16263 static const struct hda_verb alc660vd_fix_asus_gpio1_verbs[] = {
16264         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
16265         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
16266         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
16267         { }
16268 };
16269
16270 static const struct alc_fixup alc861vd_fixups[] = {
16271         [ALC660VD_FIX_ASUS_GPIO1] = {
16272                 .verbs = alc660vd_fix_asus_gpio1_verbs,
16273         },
16274 };
16275
16276 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
16277         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
16278         {}
16279 };
16280
16281 static int patch_alc861vd(struct hda_codec *codec)
16282 {
16283         struct alc_spec *spec;
16284         int err, board_config;
16285
16286         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16287         if (spec == NULL)
16288                 return -ENOMEM;
16289
16290         codec->spec = spec;
16291
16292         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
16293                                                   alc861vd_models,
16294                                                   alc861vd_cfg_tbl);
16295
16296         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
16297                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16298                        codec->chip_name);
16299                 board_config = ALC861VD_AUTO;
16300         }
16301
16302         alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups);
16303
16304         if (board_config == ALC861VD_AUTO) {
16305                 /* automatic parse from the BIOS config */
16306                 err = alc861vd_parse_auto_config(codec);
16307                 if (err < 0) {
16308                         alc_free(codec);
16309                         return err;
16310                 } else if (!err) {
16311                         printk(KERN_INFO
16312                                "hda_codec: Cannot set up configuration "
16313                                "from BIOS.  Using base mode...\n");
16314                         board_config = ALC861VD_3ST;
16315                 }
16316         }
16317
16318         err = snd_hda_attach_beep_device(codec, 0x23);
16319         if (err < 0) {
16320                 alc_free(codec);
16321                 return err;
16322         }
16323
16324         if (board_config != ALC861VD_AUTO)
16325                 setup_preset(codec, &alc861vd_presets[board_config]);
16326
16327         if (codec->vendor_id == 0x10ec0660) {
16328                 /* always turn on EAPD */
16329                 add_verb(spec, alc660vd_eapd_verbs);
16330         }
16331
16332         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
16333         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
16334
16335         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
16336         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
16337
16338         if (!spec->adc_nids) {
16339                 spec->adc_nids = alc861vd_adc_nids;
16340                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
16341         }
16342         if (!spec->capsrc_nids)
16343                 spec->capsrc_nids = alc861vd_capsrc_nids;
16344
16345         set_capture_mixer(codec);
16346         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
16347
16348         spec->vmaster_nid = 0x02;
16349
16350         codec->patch_ops = alc_patch_ops;
16351
16352         if (board_config == ALC861VD_AUTO)
16353                 spec->init_hook = alc861vd_auto_init;
16354 #ifdef CONFIG_SND_HDA_POWER_SAVE
16355         if (!spec->loopback.amplist)
16356                 spec->loopback.amplist = alc861vd_loopbacks;
16357 #endif
16358
16359         return 0;
16360 }
16361
16362 /*
16363  * ALC662 support
16364  *
16365  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
16366  * configuration.  Each pin widget can choose any input DACs and a mixer.
16367  * Each ADC is connected from a mixer of all inputs.  This makes possible
16368  * 6-channel independent captures.
16369  *
16370  * In addition, an independent DAC for the multi-playback (not used in this
16371  * driver yet).
16372  */
16373 #define ALC662_DIGOUT_NID       0x06
16374 #define ALC662_DIGIN_NID        0x0a
16375
16376 static hda_nid_t alc662_dac_nids[4] = {
16377         /* front, rear, clfe, rear_surr */
16378         0x02, 0x03, 0x04
16379 };
16380
16381 static hda_nid_t alc272_dac_nids[2] = {
16382         0x02, 0x03
16383 };
16384
16385 static hda_nid_t alc662_adc_nids[2] = {
16386         /* ADC1-2 */
16387         0x09, 0x08
16388 };
16389
16390 static hda_nid_t alc272_adc_nids[1] = {
16391         /* ADC1-2 */
16392         0x08,
16393 };
16394
16395 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
16396 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
16397
16398
16399 /* input MUX */
16400 /* FIXME: should be a matrix-type input source selection */
16401 static struct hda_input_mux alc662_capture_source = {
16402         .num_items = 4,
16403         .items = {
16404                 { "Mic", 0x0 },
16405                 { "Front Mic", 0x1 },
16406                 { "Line", 0x2 },
16407                 { "CD", 0x4 },
16408         },
16409 };
16410
16411 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
16412         .num_items = 2,
16413         .items = {
16414                 { "Mic", 0x1 },
16415                 { "Line", 0x2 },
16416         },
16417 };
16418
16419 static struct hda_input_mux alc663_capture_source = {
16420         .num_items = 3,
16421         .items = {
16422                 { "Mic", 0x0 },
16423                 { "Front Mic", 0x1 },
16424                 { "Line", 0x2 },
16425         },
16426 };
16427
16428 #if 0 /* set to 1 for testing other input sources below */
16429 static struct hda_input_mux alc272_nc10_capture_source = {
16430         .num_items = 16,
16431         .items = {
16432                 { "Autoselect Mic", 0x0 },
16433                 { "Internal Mic", 0x1 },
16434                 { "In-0x02", 0x2 },
16435                 { "In-0x03", 0x3 },
16436                 { "In-0x04", 0x4 },
16437                 { "In-0x05", 0x5 },
16438                 { "In-0x06", 0x6 },
16439                 { "In-0x07", 0x7 },
16440                 { "In-0x08", 0x8 },
16441                 { "In-0x09", 0x9 },
16442                 { "In-0x0a", 0x0a },
16443                 { "In-0x0b", 0x0b },
16444                 { "In-0x0c", 0x0c },
16445                 { "In-0x0d", 0x0d },
16446                 { "In-0x0e", 0x0e },
16447                 { "In-0x0f", 0x0f },
16448         },
16449 };
16450 #endif
16451
16452 /*
16453  * 2ch mode
16454  */
16455 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
16456         { 2, NULL }
16457 };
16458
16459 /*
16460  * 2ch mode
16461  */
16462 static struct hda_verb alc662_3ST_ch2_init[] = {
16463         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
16464         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
16465         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
16466         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
16467         { } /* end */
16468 };
16469
16470 /*
16471  * 6ch mode
16472  */
16473 static struct hda_verb alc662_3ST_ch6_init[] = {
16474         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16475         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
16476         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
16477         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16478         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
16479         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
16480         { } /* end */
16481 };
16482
16483 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
16484         { 2, alc662_3ST_ch2_init },
16485         { 6, alc662_3ST_ch6_init },
16486 };
16487
16488 /*
16489  * 2ch mode
16490  */
16491 static struct hda_verb alc662_sixstack_ch6_init[] = {
16492         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16493         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16494         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16495         { } /* end */
16496 };
16497
16498 /*
16499  * 6ch mode
16500  */
16501 static struct hda_verb alc662_sixstack_ch8_init[] = {
16502         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16503         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16504         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16505         { } /* end */
16506 };
16507
16508 static struct hda_channel_mode alc662_5stack_modes[2] = {
16509         { 2, alc662_sixstack_ch6_init },
16510         { 6, alc662_sixstack_ch8_init },
16511 };
16512
16513 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16514  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16515  */
16516
16517 static struct snd_kcontrol_new alc662_base_mixer[] = {
16518         /* output mixer control */
16519         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
16520         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16521         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
16522         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16523         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16524         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16525         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16526         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16527         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16528
16529         /*Input mixer control */
16530         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
16531         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
16532         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
16533         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
16534         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
16535         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
16536         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
16537         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
16538         { } /* end */
16539 };
16540
16541 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
16542         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16543         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16544         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16545         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16546         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16547         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16548         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16549         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16550         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16551         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16552         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16553         { } /* end */
16554 };
16555
16556 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
16557         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16558         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16559         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16560         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16561         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16562         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16563         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16564         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16565         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16566         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16567         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16568         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16569         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16570         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16571         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16572         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16573         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16574         { } /* end */
16575 };
16576
16577 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
16578         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16579         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
16580         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16581         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
16582         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16583         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16584         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16585         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16586         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16587         { } /* end */
16588 };
16589
16590 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
16591         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16592         ALC262_HIPPO_MASTER_SWITCH,
16593
16594         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
16595         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16596         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16597
16598         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16599         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16600         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16601         { } /* end */
16602 };
16603
16604 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
16605         ALC262_HIPPO_MASTER_SWITCH,
16606         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16607         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16608         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16609         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16610         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
16611         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16612         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16613         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16614         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16615         { } /* end */
16616 };
16617
16618 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
16619         .ops = &snd_hda_bind_vol,
16620         .values = {
16621                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16622                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
16623                 0
16624         },
16625 };
16626
16627 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
16628         .ops = &snd_hda_bind_sw,
16629         .values = {
16630                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16631                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16632                 0
16633         },
16634 };
16635
16636 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
16637         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16638         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
16639         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16640         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16641         { } /* end */
16642 };
16643
16644 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
16645         .ops = &snd_hda_bind_sw,
16646         .values = {
16647                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16648                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16649                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16650                 0
16651         },
16652 };
16653
16654 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
16655         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16656         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
16657         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16658         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16659         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16660         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16661
16662         { } /* end */
16663 };
16664
16665 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
16666         .ops = &snd_hda_bind_sw,
16667         .values = {
16668                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16669                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16670                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16671                 0
16672         },
16673 };
16674
16675 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
16676         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16677         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
16678         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16679         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16680         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16681         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16682         { } /* end */
16683 };
16684
16685 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
16686         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16687         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16688         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16689         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16690         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16691         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16692         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16693         { } /* end */
16694 };
16695
16696 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
16697         .ops = &snd_hda_bind_vol,
16698         .values = {
16699                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16700                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
16701                 0
16702         },
16703 };
16704
16705 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
16706         .ops = &snd_hda_bind_sw,
16707         .values = {
16708                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16709                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
16710                 0
16711         },
16712 };
16713
16714 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
16715         HDA_BIND_VOL("Master Playback Volume",
16716                                 &alc663_asus_two_bind_master_vol),
16717         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16718         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16719         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16720         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16721         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16722         { } /* end */
16723 };
16724
16725 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
16726         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16727         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16728         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16729         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16730         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16731         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16732         { } /* end */
16733 };
16734
16735 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
16736         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16737         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16738         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16739         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16740         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16741
16742         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16743         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16744         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16745         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16746         { } /* end */
16747 };
16748
16749 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
16750         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16751         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16752         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16753
16754         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16755         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16756         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16757         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16758         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16759         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16760         { } /* end */
16761 };
16762
16763 static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
16764         .ops = &snd_hda_bind_sw,
16765         .values = {
16766                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16767                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16768                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
16769                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16770                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16771                 0
16772         },
16773 };
16774
16775 static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
16776         .ops = &snd_hda_bind_sw,
16777         .values = {
16778                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16779                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
16780                 0
16781         },
16782 };
16783
16784 static struct snd_kcontrol_new alc663_mode7_mixer[] = {
16785         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
16786         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
16787         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
16788         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16789         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16790         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16791         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16792         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16793         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16794         { } /* end */
16795 };
16796
16797 static struct snd_kcontrol_new alc663_mode8_mixer[] = {
16798         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
16799         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
16800         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
16801         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16802         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16803         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16804         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16805         { } /* end */
16806 };
16807
16808
16809 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
16810         {
16811                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16812                 .name = "Channel Mode",
16813                 .info = alc_ch_mode_info,
16814                 .get = alc_ch_mode_get,
16815                 .put = alc_ch_mode_put,
16816         },
16817         { } /* end */
16818 };
16819
16820 static struct hda_verb alc662_init_verbs[] = {
16821         /* ADC: mute amp left and right */
16822         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16823         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16824
16825         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16826         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16827         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16828         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16829         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16830         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16831
16832         /* Front Pin: output 0 (0x0c) */
16833         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16834         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16835
16836         /* Rear Pin: output 1 (0x0d) */
16837         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16838         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16839
16840         /* CLFE Pin: output 2 (0x0e) */
16841         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16842         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16843
16844         /* Mic (rear) pin: input vref at 80% */
16845         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16846         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16847         /* Front Mic pin: input vref at 80% */
16848         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16849         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16850         /* Line In pin: input */
16851         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16852         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16853         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16854         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16855         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16856         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16857         /* CD pin widget for input */
16858         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16859
16860         /* FIXME: use matrix-type input source selection */
16861         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16862         /* Input mixer */
16863         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16864         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16865
16866         /* always trun on EAPD */
16867         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16868         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16869
16870         { }
16871 };
16872
16873 static struct hda_verb alc663_init_verbs[] = {
16874         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16875         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16876         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16877         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16878         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16879         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16880         { }
16881 };
16882
16883 static struct hda_verb alc272_init_verbs[] = {
16884         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16885         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16886         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16887         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16888         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16889         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16890         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16891         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16892         { }
16893 };
16894
16895 static struct hda_verb alc662_sue_init_verbs[] = {
16896         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16897         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16898         {}
16899 };
16900
16901 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
16902         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16903         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16904         {}
16905 };
16906
16907 /* Set Unsolicited Event*/
16908 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
16909         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16910         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16911         {}
16912 };
16913
16914 static struct hda_verb alc663_m51va_init_verbs[] = {
16915         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16916         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16917         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16918         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16919         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16920         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16921         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16922         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16923         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16924         {}
16925 };
16926
16927 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
16928         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16929         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16930         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16931         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16932         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16933         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16934         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16935         {}
16936 };
16937
16938 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
16939         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16940         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16941         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16942         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16943         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16944         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16945         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16946         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16947         {}
16948 };
16949
16950 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
16951         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16952         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16953         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16954         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16955         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16956         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16957         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16958         {}
16959 };
16960
16961 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
16962         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16963         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16964         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16965         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16966         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16967         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16968         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16969         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16970         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16971         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16972         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16973         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16974         {}
16975 };
16976
16977 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
16978         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16979         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16980         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16981         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16982         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16983         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16984         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16985         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16986         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16987         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16988         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16989         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16990         {}
16991 };
16992
16993 static struct hda_verb alc663_g71v_init_verbs[] = {
16994         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16995         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
16996         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
16997
16998         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16999         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17000         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17001
17002         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17003         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
17004         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17005         {}
17006 };
17007
17008 static struct hda_verb alc663_g50v_init_verbs[] = {
17009         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17010         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17011         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17012
17013         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17014         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17015         {}
17016 };
17017
17018 static struct hda_verb alc662_ecs_init_verbs[] = {
17019         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
17020         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17021         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17022         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17023         {}
17024 };
17025
17026 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
17027         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17028         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17029         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17030         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17031         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17032         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17033         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17034         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17035         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17036         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17037         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17038         {}
17039 };
17040
17041 static struct hda_verb alc272_dell_init_verbs[] = {
17042         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17043         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17044         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17045         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17046         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17047         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17048         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17049         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17050         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17051         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17052         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17053         {}
17054 };
17055
17056 static struct hda_verb alc663_mode7_init_verbs[] = {
17057         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17058         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17059         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17060         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17061         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17062         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17063         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
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, 0x01},  /* Headphone */
17067         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17068         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17069         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17070         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17071         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17072         {}
17073 };
17074
17075 static struct hda_verb alc663_mode8_init_verbs[] = {
17076         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17077         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17078         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17079         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
17080         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17081         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17082         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17083         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17084         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17085         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17086         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17087         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17088         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17089         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17090         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17091         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17092         {}
17093 };
17094
17095 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
17096         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
17097         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
17098         { } /* end */
17099 };
17100
17101 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
17102         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
17103         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
17104         { } /* end */
17105 };
17106
17107 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
17108 {
17109         unsigned int present;
17110         unsigned char bits;
17111
17112         present = snd_hda_jack_detect(codec, 0x14);
17113         bits = present ? HDA_AMP_MUTE : 0;
17114
17115         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17116                                  HDA_AMP_MUTE, bits);
17117 }
17118
17119 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
17120 {
17121         unsigned int present;
17122         unsigned char bits;
17123
17124         present = snd_hda_jack_detect(codec, 0x1b);
17125         bits = present ? HDA_AMP_MUTE : 0;
17126
17127         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17128                                  HDA_AMP_MUTE, bits);
17129         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17130                                  HDA_AMP_MUTE, bits);
17131 }
17132
17133 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
17134                                            unsigned int res)
17135 {
17136         if ((res >> 26) == ALC880_HP_EVENT)
17137                 alc662_lenovo_101e_all_automute(codec);
17138         if ((res >> 26) == ALC880_FRONT_EVENT)
17139                 alc662_lenovo_101e_ispeaker_automute(codec);
17140 }
17141
17142 /* unsolicited event for HP jack sensing */
17143 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
17144                                      unsigned int res)
17145 {
17146         if ((res >> 26) == ALC880_MIC_EVENT)
17147                 alc_mic_automute(codec);
17148         else
17149                 alc262_hippo_unsol_event(codec, res);
17150 }
17151
17152 static void alc662_eeepc_setup(struct hda_codec *codec)
17153 {
17154         struct alc_spec *spec = codec->spec;
17155
17156         alc262_hippo1_setup(codec);
17157         spec->ext_mic.pin = 0x18;
17158         spec->ext_mic.mux_idx = 0;
17159         spec->int_mic.pin = 0x19;
17160         spec->int_mic.mux_idx = 1;
17161         spec->auto_mic = 1;
17162 }
17163
17164 static void alc662_eeepc_inithook(struct hda_codec *codec)
17165 {
17166         alc262_hippo_automute(codec);
17167         alc_mic_automute(codec);
17168 }
17169
17170 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
17171 {
17172         struct alc_spec *spec = codec->spec;
17173
17174         spec->autocfg.hp_pins[0] = 0x14;
17175         spec->autocfg.speaker_pins[0] = 0x1b;
17176 }
17177
17178 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
17179
17180 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
17181 {
17182         unsigned int present;
17183         unsigned char bits;
17184
17185         present = snd_hda_jack_detect(codec, 0x21);
17186         bits = present ? HDA_AMP_MUTE : 0;
17187         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17188                                  HDA_AMP_MUTE, bits);
17189         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17190                                  HDA_AMP_MUTE, bits);
17191 }
17192
17193 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
17194 {
17195         unsigned int present;
17196         unsigned char bits;
17197
17198         present = snd_hda_jack_detect(codec, 0x21);
17199         bits = present ? HDA_AMP_MUTE : 0;
17200         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17201                                  HDA_AMP_MUTE, bits);
17202         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17203                                  HDA_AMP_MUTE, bits);
17204         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
17205                                  HDA_AMP_MUTE, bits);
17206         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
17207                                  HDA_AMP_MUTE, bits);
17208 }
17209
17210 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
17211 {
17212         unsigned int present;
17213         unsigned char bits;
17214
17215         present = snd_hda_jack_detect(codec, 0x15);
17216         bits = present ? HDA_AMP_MUTE : 0;
17217         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17218                                  HDA_AMP_MUTE, bits);
17219         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17220                                  HDA_AMP_MUTE, bits);
17221         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
17222                                  HDA_AMP_MUTE, bits);
17223         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
17224                                  HDA_AMP_MUTE, bits);
17225 }
17226
17227 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
17228 {
17229         unsigned int present;
17230         unsigned char bits;
17231
17232         present = snd_hda_jack_detect(codec, 0x1b);
17233         bits = present ? 0 : PIN_OUT;
17234         snd_hda_codec_write(codec, 0x14, 0,
17235                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
17236 }
17237
17238 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
17239 {
17240         unsigned int present1, present2;
17241
17242         present1 = snd_hda_jack_detect(codec, 0x21);
17243         present2 = snd_hda_jack_detect(codec, 0x15);
17244
17245         if (present1 || present2) {
17246                 snd_hda_codec_write_cache(codec, 0x14, 0,
17247                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17248         } else {
17249                 snd_hda_codec_write_cache(codec, 0x14, 0,
17250                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17251         }
17252 }
17253
17254 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
17255 {
17256         unsigned int present1, present2;
17257
17258         present1 = snd_hda_jack_detect(codec, 0x1b);
17259         present2 = snd_hda_jack_detect(codec, 0x15);
17260
17261         if (present1 || present2) {
17262                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17263                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
17264                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17265                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
17266         } else {
17267                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17268                                          HDA_AMP_MUTE, 0);
17269                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17270                                          HDA_AMP_MUTE, 0);
17271         }
17272 }
17273
17274 static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
17275 {
17276         unsigned int present1, present2;
17277
17278         present1 = snd_hda_codec_read(codec, 0x1b, 0,
17279                         AC_VERB_GET_PIN_SENSE, 0)
17280                         & AC_PINSENSE_PRESENCE;
17281         present2 = snd_hda_codec_read(codec, 0x21, 0,
17282                         AC_VERB_GET_PIN_SENSE, 0)
17283                         & AC_PINSENSE_PRESENCE;
17284
17285         if (present1 || present2) {
17286                 snd_hda_codec_write_cache(codec, 0x14, 0,
17287                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17288                 snd_hda_codec_write_cache(codec, 0x17, 0,
17289                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17290         } else {
17291                 snd_hda_codec_write_cache(codec, 0x14, 0,
17292                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17293                 snd_hda_codec_write_cache(codec, 0x17, 0,
17294                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17295         }
17296 }
17297
17298 static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
17299 {
17300         unsigned int present1, present2;
17301
17302         present1 = snd_hda_codec_read(codec, 0x21, 0,
17303                         AC_VERB_GET_PIN_SENSE, 0)
17304                         & AC_PINSENSE_PRESENCE;
17305         present2 = snd_hda_codec_read(codec, 0x15, 0,
17306                         AC_VERB_GET_PIN_SENSE, 0)
17307                         & AC_PINSENSE_PRESENCE;
17308
17309         if (present1 || present2) {
17310                 snd_hda_codec_write_cache(codec, 0x14, 0,
17311                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17312                 snd_hda_codec_write_cache(codec, 0x17, 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                 snd_hda_codec_write_cache(codec, 0x17, 0,
17318                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17319         }
17320 }
17321
17322 static void alc663_m51va_unsol_event(struct hda_codec *codec,
17323                                            unsigned int res)
17324 {
17325         switch (res >> 26) {
17326         case ALC880_HP_EVENT:
17327                 alc663_m51va_speaker_automute(codec);
17328                 break;
17329         case ALC880_MIC_EVENT:
17330                 alc_mic_automute(codec);
17331                 break;
17332         }
17333 }
17334
17335 static void alc663_m51va_setup(struct hda_codec *codec)
17336 {
17337         struct alc_spec *spec = codec->spec;
17338         spec->ext_mic.pin = 0x18;
17339         spec->ext_mic.mux_idx = 0;
17340         spec->int_mic.pin = 0x12;
17341         spec->int_mic.mux_idx = 9;
17342         spec->auto_mic = 1;
17343 }
17344
17345 static void alc663_m51va_inithook(struct hda_codec *codec)
17346 {
17347         alc663_m51va_speaker_automute(codec);
17348         alc_mic_automute(codec);
17349 }
17350
17351 /* ***************** Mode1 ******************************/
17352 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
17353
17354 static void alc663_mode1_setup(struct hda_codec *codec)
17355 {
17356         struct alc_spec *spec = codec->spec;
17357         spec->ext_mic.pin = 0x18;
17358         spec->ext_mic.mux_idx = 0;
17359         spec->int_mic.pin = 0x19;
17360         spec->int_mic.mux_idx = 1;
17361         spec->auto_mic = 1;
17362 }
17363
17364 #define alc663_mode1_inithook           alc663_m51va_inithook
17365
17366 /* ***************** Mode2 ******************************/
17367 static void alc662_mode2_unsol_event(struct hda_codec *codec,
17368                                            unsigned int res)
17369 {
17370         switch (res >> 26) {
17371         case ALC880_HP_EVENT:
17372                 alc662_f5z_speaker_automute(codec);
17373                 break;
17374         case ALC880_MIC_EVENT:
17375                 alc_mic_automute(codec);
17376                 break;
17377         }
17378 }
17379
17380 #define alc662_mode2_setup      alc663_mode1_setup
17381
17382 static void alc662_mode2_inithook(struct hda_codec *codec)
17383 {
17384         alc662_f5z_speaker_automute(codec);
17385         alc_mic_automute(codec);
17386 }
17387 /* ***************** Mode3 ******************************/
17388 static void alc663_mode3_unsol_event(struct hda_codec *codec,
17389                                            unsigned int res)
17390 {
17391         switch (res >> 26) {
17392         case ALC880_HP_EVENT:
17393                 alc663_two_hp_m1_speaker_automute(codec);
17394                 break;
17395         case ALC880_MIC_EVENT:
17396                 alc_mic_automute(codec);
17397                 break;
17398         }
17399 }
17400
17401 #define alc663_mode3_setup      alc663_mode1_setup
17402
17403 static void alc663_mode3_inithook(struct hda_codec *codec)
17404 {
17405         alc663_two_hp_m1_speaker_automute(codec);
17406         alc_mic_automute(codec);
17407 }
17408 /* ***************** Mode4 ******************************/
17409 static void alc663_mode4_unsol_event(struct hda_codec *codec,
17410                                            unsigned int res)
17411 {
17412         switch (res >> 26) {
17413         case ALC880_HP_EVENT:
17414                 alc663_21jd_two_speaker_automute(codec);
17415                 break;
17416         case ALC880_MIC_EVENT:
17417                 alc_mic_automute(codec);
17418                 break;
17419         }
17420 }
17421
17422 #define alc663_mode4_setup      alc663_mode1_setup
17423
17424 static void alc663_mode4_inithook(struct hda_codec *codec)
17425 {
17426         alc663_21jd_two_speaker_automute(codec);
17427         alc_mic_automute(codec);
17428 }
17429 /* ***************** Mode5 ******************************/
17430 static void alc663_mode5_unsol_event(struct hda_codec *codec,
17431                                            unsigned int res)
17432 {
17433         switch (res >> 26) {
17434         case ALC880_HP_EVENT:
17435                 alc663_15jd_two_speaker_automute(codec);
17436                 break;
17437         case ALC880_MIC_EVENT:
17438                 alc_mic_automute(codec);
17439                 break;
17440         }
17441 }
17442
17443 #define alc663_mode5_setup      alc663_mode1_setup
17444
17445 static void alc663_mode5_inithook(struct hda_codec *codec)
17446 {
17447         alc663_15jd_two_speaker_automute(codec);
17448         alc_mic_automute(codec);
17449 }
17450 /* ***************** Mode6 ******************************/
17451 static void alc663_mode6_unsol_event(struct hda_codec *codec,
17452                                            unsigned int res)
17453 {
17454         switch (res >> 26) {
17455         case ALC880_HP_EVENT:
17456                 alc663_two_hp_m2_speaker_automute(codec);
17457                 break;
17458         case ALC880_MIC_EVENT:
17459                 alc_mic_automute(codec);
17460                 break;
17461         }
17462 }
17463
17464 #define alc663_mode6_setup      alc663_mode1_setup
17465
17466 static void alc663_mode6_inithook(struct hda_codec *codec)
17467 {
17468         alc663_two_hp_m2_speaker_automute(codec);
17469         alc_mic_automute(codec);
17470 }
17471
17472 /* ***************** Mode7 ******************************/
17473 static void alc663_mode7_unsol_event(struct hda_codec *codec,
17474                                            unsigned int res)
17475 {
17476         switch (res >> 26) {
17477         case ALC880_HP_EVENT:
17478                 alc663_two_hp_m7_speaker_automute(codec);
17479                 break;
17480         case ALC880_MIC_EVENT:
17481                 alc_mic_automute(codec);
17482                 break;
17483         }
17484 }
17485
17486 #define alc663_mode7_setup      alc663_mode1_setup
17487
17488 static void alc663_mode7_inithook(struct hda_codec *codec)
17489 {
17490         alc663_two_hp_m7_speaker_automute(codec);
17491         alc_mic_automute(codec);
17492 }
17493
17494 /* ***************** Mode8 ******************************/
17495 static void alc663_mode8_unsol_event(struct hda_codec *codec,
17496                                            unsigned int res)
17497 {
17498         switch (res >> 26) {
17499         case ALC880_HP_EVENT:
17500                 alc663_two_hp_m8_speaker_automute(codec);
17501                 break;
17502         case ALC880_MIC_EVENT:
17503                 alc_mic_automute(codec);
17504                 break;
17505         }
17506 }
17507
17508 #define alc663_mode8_setup      alc663_m51va_setup
17509
17510 static void alc663_mode8_inithook(struct hda_codec *codec)
17511 {
17512         alc663_two_hp_m8_speaker_automute(codec);
17513         alc_mic_automute(codec);
17514 }
17515
17516 static void alc663_g71v_hp_automute(struct hda_codec *codec)
17517 {
17518         unsigned int present;
17519         unsigned char bits;
17520
17521         present = snd_hda_jack_detect(codec, 0x21);
17522         bits = present ? HDA_AMP_MUTE : 0;
17523         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17524                                  HDA_AMP_MUTE, bits);
17525         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17526                                  HDA_AMP_MUTE, bits);
17527 }
17528
17529 static void alc663_g71v_front_automute(struct hda_codec *codec)
17530 {
17531         unsigned int present;
17532         unsigned char bits;
17533
17534         present = snd_hda_jack_detect(codec, 0x15);
17535         bits = present ? HDA_AMP_MUTE : 0;
17536         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17537                                  HDA_AMP_MUTE, bits);
17538 }
17539
17540 static void alc663_g71v_unsol_event(struct hda_codec *codec,
17541                                            unsigned int res)
17542 {
17543         switch (res >> 26) {
17544         case ALC880_HP_EVENT:
17545                 alc663_g71v_hp_automute(codec);
17546                 break;
17547         case ALC880_FRONT_EVENT:
17548                 alc663_g71v_front_automute(codec);
17549                 break;
17550         case ALC880_MIC_EVENT:
17551                 alc_mic_automute(codec);
17552                 break;
17553         }
17554 }
17555
17556 #define alc663_g71v_setup       alc663_m51va_setup
17557
17558 static void alc663_g71v_inithook(struct hda_codec *codec)
17559 {
17560         alc663_g71v_front_automute(codec);
17561         alc663_g71v_hp_automute(codec);
17562         alc_mic_automute(codec);
17563 }
17564
17565 static void alc663_g50v_unsol_event(struct hda_codec *codec,
17566                                            unsigned int res)
17567 {
17568         switch (res >> 26) {
17569         case ALC880_HP_EVENT:
17570                 alc663_m51va_speaker_automute(codec);
17571                 break;
17572         case ALC880_MIC_EVENT:
17573                 alc_mic_automute(codec);
17574                 break;
17575         }
17576 }
17577
17578 #define alc663_g50v_setup       alc663_m51va_setup
17579
17580 static void alc663_g50v_inithook(struct hda_codec *codec)
17581 {
17582         alc663_m51va_speaker_automute(codec);
17583         alc_mic_automute(codec);
17584 }
17585
17586 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
17587         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17588         ALC262_HIPPO_MASTER_SWITCH,
17589
17590         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
17591         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
17592         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
17593
17594         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
17595         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17596         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17597         { } /* end */
17598 };
17599
17600 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
17601         /* Master Playback automatically created from Speaker and Headphone */
17602         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17603         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17604         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17605         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17606
17607         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17608         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17609         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
17610
17611         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17612         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17613         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
17614         { } /* end */
17615 };
17616
17617 #ifdef CONFIG_SND_HDA_POWER_SAVE
17618 #define alc662_loopbacks        alc880_loopbacks
17619 #endif
17620
17621
17622 /* pcm configuration: identical with ALC880 */
17623 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
17624 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
17625 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
17626 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
17627
17628 /*
17629  * configuration and preset
17630  */
17631 static const char *alc662_models[ALC662_MODEL_LAST] = {
17632         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
17633         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
17634         [ALC662_3ST_6ch]        = "3stack-6ch",
17635         [ALC662_5ST_DIG]        = "6stack-dig",
17636         [ALC662_LENOVO_101E]    = "lenovo-101e",
17637         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
17638         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
17639         [ALC662_ECS] = "ecs",
17640         [ALC663_ASUS_M51VA] = "m51va",
17641         [ALC663_ASUS_G71V] = "g71v",
17642         [ALC663_ASUS_H13] = "h13",
17643         [ALC663_ASUS_G50V] = "g50v",
17644         [ALC663_ASUS_MODE1] = "asus-mode1",
17645         [ALC662_ASUS_MODE2] = "asus-mode2",
17646         [ALC663_ASUS_MODE3] = "asus-mode3",
17647         [ALC663_ASUS_MODE4] = "asus-mode4",
17648         [ALC663_ASUS_MODE5] = "asus-mode5",
17649         [ALC663_ASUS_MODE6] = "asus-mode6",
17650         [ALC663_ASUS_MODE7] = "asus-mode7",
17651         [ALC663_ASUS_MODE8] = "asus-mode8",
17652         [ALC272_DELL]           = "dell",
17653         [ALC272_DELL_ZM1]       = "dell-zm1",
17654         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
17655         [ALC662_AUTO]           = "auto",
17656 };
17657
17658 static struct snd_pci_quirk alc662_cfg_tbl[] = {
17659         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
17660         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
17661         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
17662         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
17663         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
17664         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
17665         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
17666         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
17667         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
17668         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
17669         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
17670         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
17671         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
17672         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
17673         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
17674         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
17675         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
17676         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
17677         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
17678         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
17679         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
17680         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
17681         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
17682         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
17683         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
17684         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
17685         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
17686         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
17687         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
17688         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
17689         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
17690         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
17691         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
17692         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
17693         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
17694         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
17695         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
17696         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
17697         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
17698         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
17699         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
17700         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
17701         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
17702         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
17703         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
17704         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
17705         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
17706         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
17707         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
17708         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
17709         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
17710         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
17711         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
17712         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
17713         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
17714         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
17715         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
17716         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
17717         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
17718         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
17719         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
17720         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
17721         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
17722         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
17723                       ALC662_3ST_6ch_DIG),
17724         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
17725         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
17726         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
17727                       ALC662_3ST_6ch_DIG),
17728         SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
17729         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
17730         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
17731         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
17732         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
17733                                         ALC662_3ST_6ch_DIG),
17734         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
17735                            ALC663_ASUS_H13),
17736         SND_PCI_QUIRK(0x8086, 0xd604, "Intel mobo", ALC662_3ST_2ch_DIG),
17737         {}
17738 };
17739
17740 static struct alc_config_preset alc662_presets[] = {
17741         [ALC662_3ST_2ch_DIG] = {
17742                 .mixers = { alc662_3ST_2ch_mixer },
17743                 .init_verbs = { alc662_init_verbs },
17744                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17745                 .dac_nids = alc662_dac_nids,
17746                 .dig_out_nid = ALC662_DIGOUT_NID,
17747                 .dig_in_nid = ALC662_DIGIN_NID,
17748                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17749                 .channel_mode = alc662_3ST_2ch_modes,
17750                 .input_mux = &alc662_capture_source,
17751         },
17752         [ALC662_3ST_6ch_DIG] = {
17753                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17754                 .init_verbs = { alc662_init_verbs },
17755                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17756                 .dac_nids = alc662_dac_nids,
17757                 .dig_out_nid = ALC662_DIGOUT_NID,
17758                 .dig_in_nid = ALC662_DIGIN_NID,
17759                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17760                 .channel_mode = alc662_3ST_6ch_modes,
17761                 .need_dac_fix = 1,
17762                 .input_mux = &alc662_capture_source,
17763         },
17764         [ALC662_3ST_6ch] = {
17765                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17766                 .init_verbs = { alc662_init_verbs },
17767                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17768                 .dac_nids = alc662_dac_nids,
17769                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17770                 .channel_mode = alc662_3ST_6ch_modes,
17771                 .need_dac_fix = 1,
17772                 .input_mux = &alc662_capture_source,
17773         },
17774         [ALC662_5ST_DIG] = {
17775                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
17776                 .init_verbs = { alc662_init_verbs },
17777                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17778                 .dac_nids = alc662_dac_nids,
17779                 .dig_out_nid = ALC662_DIGOUT_NID,
17780                 .dig_in_nid = ALC662_DIGIN_NID,
17781                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
17782                 .channel_mode = alc662_5stack_modes,
17783                 .input_mux = &alc662_capture_source,
17784         },
17785         [ALC662_LENOVO_101E] = {
17786                 .mixers = { alc662_lenovo_101e_mixer },
17787                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
17788                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17789                 .dac_nids = alc662_dac_nids,
17790                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17791                 .channel_mode = alc662_3ST_2ch_modes,
17792                 .input_mux = &alc662_lenovo_101e_capture_source,
17793                 .unsol_event = alc662_lenovo_101e_unsol_event,
17794                 .init_hook = alc662_lenovo_101e_all_automute,
17795         },
17796         [ALC662_ASUS_EEEPC_P701] = {
17797                 .mixers = { alc662_eeepc_p701_mixer },
17798                 .init_verbs = { alc662_init_verbs,
17799                                 alc662_eeepc_sue_init_verbs },
17800                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17801                 .dac_nids = alc662_dac_nids,
17802                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17803                 .channel_mode = alc662_3ST_2ch_modes,
17804                 .unsol_event = alc662_eeepc_unsol_event,
17805                 .setup = alc662_eeepc_setup,
17806                 .init_hook = alc662_eeepc_inithook,
17807         },
17808         [ALC662_ASUS_EEEPC_EP20] = {
17809                 .mixers = { alc662_eeepc_ep20_mixer,
17810                             alc662_chmode_mixer },
17811                 .init_verbs = { alc662_init_verbs,
17812                                 alc662_eeepc_ep20_sue_init_verbs },
17813                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17814                 .dac_nids = alc662_dac_nids,
17815                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17816                 .channel_mode = alc662_3ST_6ch_modes,
17817                 .input_mux = &alc662_lenovo_101e_capture_source,
17818                 .unsol_event = alc662_eeepc_unsol_event,
17819                 .setup = alc662_eeepc_ep20_setup,
17820                 .init_hook = alc662_eeepc_ep20_inithook,
17821         },
17822         [ALC662_ECS] = {
17823                 .mixers = { alc662_ecs_mixer },
17824                 .init_verbs = { alc662_init_verbs,
17825                                 alc662_ecs_init_verbs },
17826                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17827                 .dac_nids = alc662_dac_nids,
17828                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17829                 .channel_mode = alc662_3ST_2ch_modes,
17830                 .unsol_event = alc662_eeepc_unsol_event,
17831                 .setup = alc662_eeepc_setup,
17832                 .init_hook = alc662_eeepc_inithook,
17833         },
17834         [ALC663_ASUS_M51VA] = {
17835                 .mixers = { alc663_m51va_mixer },
17836                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17837                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17838                 .dac_nids = alc662_dac_nids,
17839                 .dig_out_nid = ALC662_DIGOUT_NID,
17840                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17841                 .channel_mode = alc662_3ST_2ch_modes,
17842                 .unsol_event = alc663_m51va_unsol_event,
17843                 .setup = alc663_m51va_setup,
17844                 .init_hook = alc663_m51va_inithook,
17845         },
17846         [ALC663_ASUS_G71V] = {
17847                 .mixers = { alc663_g71v_mixer },
17848                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
17849                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17850                 .dac_nids = alc662_dac_nids,
17851                 .dig_out_nid = ALC662_DIGOUT_NID,
17852                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17853                 .channel_mode = alc662_3ST_2ch_modes,
17854                 .unsol_event = alc663_g71v_unsol_event,
17855                 .setup = alc663_g71v_setup,
17856                 .init_hook = alc663_g71v_inithook,
17857         },
17858         [ALC663_ASUS_H13] = {
17859                 .mixers = { alc663_m51va_mixer },
17860                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17861                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17862                 .dac_nids = alc662_dac_nids,
17863                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17864                 .channel_mode = alc662_3ST_2ch_modes,
17865                 .unsol_event = alc663_m51va_unsol_event,
17866                 .init_hook = alc663_m51va_inithook,
17867         },
17868         [ALC663_ASUS_G50V] = {
17869                 .mixers = { alc663_g50v_mixer },
17870                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
17871                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17872                 .dac_nids = alc662_dac_nids,
17873                 .dig_out_nid = ALC662_DIGOUT_NID,
17874                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17875                 .channel_mode = alc662_3ST_6ch_modes,
17876                 .input_mux = &alc663_capture_source,
17877                 .unsol_event = alc663_g50v_unsol_event,
17878                 .setup = alc663_g50v_setup,
17879                 .init_hook = alc663_g50v_inithook,
17880         },
17881         [ALC663_ASUS_MODE1] = {
17882                 .mixers = { alc663_m51va_mixer },
17883                 .cap_mixer = alc662_auto_capture_mixer,
17884                 .init_verbs = { alc662_init_verbs,
17885                                 alc663_21jd_amic_init_verbs },
17886                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17887                 .hp_nid = 0x03,
17888                 .dac_nids = alc662_dac_nids,
17889                 .dig_out_nid = ALC662_DIGOUT_NID,
17890                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17891                 .channel_mode = alc662_3ST_2ch_modes,
17892                 .unsol_event = alc663_mode1_unsol_event,
17893                 .setup = alc663_mode1_setup,
17894                 .init_hook = alc663_mode1_inithook,
17895         },
17896         [ALC662_ASUS_MODE2] = {
17897                 .mixers = { alc662_1bjd_mixer },
17898                 .cap_mixer = alc662_auto_capture_mixer,
17899                 .init_verbs = { alc662_init_verbs,
17900                                 alc662_1bjd_amic_init_verbs },
17901                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17902                 .dac_nids = alc662_dac_nids,
17903                 .dig_out_nid = ALC662_DIGOUT_NID,
17904                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17905                 .channel_mode = alc662_3ST_2ch_modes,
17906                 .unsol_event = alc662_mode2_unsol_event,
17907                 .setup = alc662_mode2_setup,
17908                 .init_hook = alc662_mode2_inithook,
17909         },
17910         [ALC663_ASUS_MODE3] = {
17911                 .mixers = { alc663_two_hp_m1_mixer },
17912                 .cap_mixer = alc662_auto_capture_mixer,
17913                 .init_verbs = { alc662_init_verbs,
17914                                 alc663_two_hp_amic_m1_init_verbs },
17915                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17916                 .hp_nid = 0x03,
17917                 .dac_nids = alc662_dac_nids,
17918                 .dig_out_nid = ALC662_DIGOUT_NID,
17919                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17920                 .channel_mode = alc662_3ST_2ch_modes,
17921                 .unsol_event = alc663_mode3_unsol_event,
17922                 .setup = alc663_mode3_setup,
17923                 .init_hook = alc663_mode3_inithook,
17924         },
17925         [ALC663_ASUS_MODE4] = {
17926                 .mixers = { alc663_asus_21jd_clfe_mixer },
17927                 .cap_mixer = alc662_auto_capture_mixer,
17928                 .init_verbs = { alc662_init_verbs,
17929                                 alc663_21jd_amic_init_verbs},
17930                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17931                 .hp_nid = 0x03,
17932                 .dac_nids = alc662_dac_nids,
17933                 .dig_out_nid = ALC662_DIGOUT_NID,
17934                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17935                 .channel_mode = alc662_3ST_2ch_modes,
17936                 .unsol_event = alc663_mode4_unsol_event,
17937                 .setup = alc663_mode4_setup,
17938                 .init_hook = alc663_mode4_inithook,
17939         },
17940         [ALC663_ASUS_MODE5] = {
17941                 .mixers = { alc663_asus_15jd_clfe_mixer },
17942                 .cap_mixer = alc662_auto_capture_mixer,
17943                 .init_verbs = { alc662_init_verbs,
17944                                 alc663_15jd_amic_init_verbs },
17945                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17946                 .hp_nid = 0x03,
17947                 .dac_nids = alc662_dac_nids,
17948                 .dig_out_nid = ALC662_DIGOUT_NID,
17949                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17950                 .channel_mode = alc662_3ST_2ch_modes,
17951                 .unsol_event = alc663_mode5_unsol_event,
17952                 .setup = alc663_mode5_setup,
17953                 .init_hook = alc663_mode5_inithook,
17954         },
17955         [ALC663_ASUS_MODE6] = {
17956                 .mixers = { alc663_two_hp_m2_mixer },
17957                 .cap_mixer = alc662_auto_capture_mixer,
17958                 .init_verbs = { alc662_init_verbs,
17959                                 alc663_two_hp_amic_m2_init_verbs },
17960                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17961                 .hp_nid = 0x03,
17962                 .dac_nids = alc662_dac_nids,
17963                 .dig_out_nid = ALC662_DIGOUT_NID,
17964                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17965                 .channel_mode = alc662_3ST_2ch_modes,
17966                 .unsol_event = alc663_mode6_unsol_event,
17967                 .setup = alc663_mode6_setup,
17968                 .init_hook = alc663_mode6_inithook,
17969         },
17970         [ALC663_ASUS_MODE7] = {
17971                 .mixers = { alc663_mode7_mixer },
17972                 .cap_mixer = alc662_auto_capture_mixer,
17973                 .init_verbs = { alc662_init_verbs,
17974                                 alc663_mode7_init_verbs },
17975                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17976                 .hp_nid = 0x03,
17977                 .dac_nids = alc662_dac_nids,
17978                 .dig_out_nid = ALC662_DIGOUT_NID,
17979                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17980                 .channel_mode = alc662_3ST_2ch_modes,
17981                 .unsol_event = alc663_mode7_unsol_event,
17982                 .setup = alc663_mode7_setup,
17983                 .init_hook = alc663_mode7_inithook,
17984         },
17985         [ALC663_ASUS_MODE8] = {
17986                 .mixers = { alc663_mode8_mixer },
17987                 .cap_mixer = alc662_auto_capture_mixer,
17988                 .init_verbs = { alc662_init_verbs,
17989                                 alc663_mode8_init_verbs },
17990                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17991                 .hp_nid = 0x03,
17992                 .dac_nids = alc662_dac_nids,
17993                 .dig_out_nid = ALC662_DIGOUT_NID,
17994                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17995                 .channel_mode = alc662_3ST_2ch_modes,
17996                 .unsol_event = alc663_mode8_unsol_event,
17997                 .setup = alc663_mode8_setup,
17998                 .init_hook = alc663_mode8_inithook,
17999         },
18000         [ALC272_DELL] = {
18001                 .mixers = { alc663_m51va_mixer },
18002                 .cap_mixer = alc272_auto_capture_mixer,
18003                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
18004                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18005                 .dac_nids = alc662_dac_nids,
18006                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18007                 .adc_nids = alc272_adc_nids,
18008                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
18009                 .capsrc_nids = alc272_capsrc_nids,
18010                 .channel_mode = alc662_3ST_2ch_modes,
18011                 .unsol_event = alc663_m51va_unsol_event,
18012                 .setup = alc663_m51va_setup,
18013                 .init_hook = alc663_m51va_inithook,
18014         },
18015         [ALC272_DELL_ZM1] = {
18016                 .mixers = { alc663_m51va_mixer },
18017                 .cap_mixer = alc662_auto_capture_mixer,
18018                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
18019                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18020                 .dac_nids = alc662_dac_nids,
18021                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18022                 .adc_nids = alc662_adc_nids,
18023                 .num_adc_nids = 1,
18024                 .capsrc_nids = alc662_capsrc_nids,
18025                 .channel_mode = alc662_3ST_2ch_modes,
18026                 .unsol_event = alc663_m51va_unsol_event,
18027                 .setup = alc663_m51va_setup,
18028                 .init_hook = alc663_m51va_inithook,
18029         },
18030         [ALC272_SAMSUNG_NC10] = {
18031                 .mixers = { alc272_nc10_mixer },
18032                 .init_verbs = { alc662_init_verbs,
18033                                 alc663_21jd_amic_init_verbs },
18034                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18035                 .dac_nids = alc272_dac_nids,
18036                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18037                 .channel_mode = alc662_3ST_2ch_modes,
18038                 /*.input_mux = &alc272_nc10_capture_source,*/
18039                 .unsol_event = alc663_mode4_unsol_event,
18040                 .setup = alc663_mode4_setup,
18041                 .init_hook = alc663_mode4_inithook,
18042         },
18043 };
18044
18045
18046 /*
18047  * BIOS auto configuration
18048  */
18049
18050 /* convert from MIX nid to DAC */
18051 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
18052 {
18053         if (nid == 0x0f)
18054                 return 0x02;
18055         else if (nid >= 0x0c && nid <= 0x0e)
18056                 return nid - 0x0c + 0x02;
18057         else
18058                 return 0;
18059 }
18060
18061 /* get MIX nid connected to the given pin targeted to DAC */
18062 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
18063                                    hda_nid_t dac)
18064 {
18065         hda_nid_t mix[4];
18066         int i, num;
18067
18068         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
18069         for (i = 0; i < num; i++) {
18070                 if (alc662_mix_to_dac(mix[i]) == dac)
18071                         return mix[i];
18072         }
18073         return 0;
18074 }
18075
18076 /* look for an empty DAC slot */
18077 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
18078 {
18079         struct alc_spec *spec = codec->spec;
18080         hda_nid_t srcs[5];
18081         int i, j, num;
18082
18083         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
18084         if (num < 0)
18085                 return 0;
18086         for (i = 0; i < num; i++) {
18087                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
18088                 if (!nid)
18089                         continue;
18090                 for (j = 0; j < spec->multiout.num_dacs; j++)
18091                         if (spec->multiout.dac_nids[j] == nid)
18092                                 break;
18093                 if (j >= spec->multiout.num_dacs)
18094                         return nid;
18095         }
18096         return 0;
18097 }
18098
18099 /* fill in the dac_nids table from the parsed pin configuration */
18100 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
18101                                      const struct auto_pin_cfg *cfg)
18102 {
18103         struct alc_spec *spec = codec->spec;
18104         int i;
18105         hda_nid_t dac;
18106
18107         spec->multiout.dac_nids = spec->private_dac_nids;
18108         for (i = 0; i < cfg->line_outs; i++) {
18109                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
18110                 if (!dac)
18111                         continue;
18112                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
18113         }
18114         return 0;
18115 }
18116
18117 static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
18118                               hda_nid_t nid, unsigned int chs)
18119 {
18120         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
18121                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
18122 }
18123
18124 static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
18125                              hda_nid_t nid, unsigned int chs)
18126 {
18127         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
18128                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
18129 }
18130
18131 #define alc662_add_stereo_vol(spec, pfx, nid) \
18132         alc662_add_vol_ctl(spec, pfx, nid, 3)
18133 #define alc662_add_stereo_sw(spec, pfx, nid) \
18134         alc662_add_sw_ctl(spec, pfx, nid, 3)
18135
18136 /* add playback controls from the parsed DAC table */
18137 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
18138                                              const struct auto_pin_cfg *cfg)
18139 {
18140         struct alc_spec *spec = codec->spec;
18141         static const char *chname[4] = {
18142                 "Front", "Surround", NULL /*CLFE*/, "Side"
18143         };
18144         hda_nid_t nid, mix;
18145         int i, err;
18146
18147         for (i = 0; i < cfg->line_outs; i++) {
18148                 nid = spec->multiout.dac_nids[i];
18149                 if (!nid)
18150                         continue;
18151                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
18152                 if (!mix)
18153                         continue;
18154                 if (i == 2) {
18155                         /* Center/LFE */
18156                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
18157                         if (err < 0)
18158                                 return err;
18159                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
18160                         if (err < 0)
18161                                 return err;
18162                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
18163                         if (err < 0)
18164                                 return err;
18165                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
18166                         if (err < 0)
18167                                 return err;
18168                 } else {
18169                         const char *pfx;
18170                         if (cfg->line_outs == 1 &&
18171                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
18172                                 if (cfg->hp_outs)
18173                                         pfx = "Speaker";
18174                                 else
18175                                         pfx = "PCM";
18176                         } else
18177                                 pfx = chname[i];
18178                         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
18179                         if (err < 0)
18180                                 return err;
18181                         if (cfg->line_outs == 1 &&
18182                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
18183                                 pfx = "Speaker";
18184                         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
18185                         if (err < 0)
18186                                 return err;
18187                 }
18188         }
18189         return 0;
18190 }
18191
18192 /* add playback controls for speaker and HP outputs */
18193 /* return DAC nid if any new DAC is assigned */
18194 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
18195                                         const char *pfx)
18196 {
18197         struct alc_spec *spec = codec->spec;
18198         hda_nid_t nid, mix;
18199         int err;
18200
18201         if (!pin)
18202                 return 0;
18203         nid = alc662_look_for_dac(codec, pin);
18204         if (!nid) {
18205                 /* the corresponding DAC is already occupied */
18206                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
18207                         return 0; /* no way */
18208                 /* create a switch only */
18209                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
18210                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
18211         }
18212
18213         mix = alc662_dac_to_mix(codec, pin, nid);
18214         if (!mix)
18215                 return 0;
18216         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
18217         if (err < 0)
18218                 return err;
18219         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
18220         if (err < 0)
18221                 return err;
18222         return nid;
18223 }
18224
18225 /* create playback/capture controls for input pins */
18226 #define alc662_auto_create_input_ctls \
18227         alc882_auto_create_input_ctls
18228
18229 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
18230                                               hda_nid_t nid, int pin_type,
18231                                               hda_nid_t dac)
18232 {
18233         int i, num;
18234         hda_nid_t srcs[4];
18235
18236         alc_set_pin_output(codec, nid, pin_type);
18237         /* need the manual connection? */
18238         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
18239         if (num <= 1)
18240                 return;
18241         for (i = 0; i < num; i++) {
18242                 if (alc662_mix_to_dac(srcs[i]) != dac)
18243                         continue;
18244                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
18245                 return;
18246         }
18247 }
18248
18249 static void alc662_auto_init_multi_out(struct hda_codec *codec)
18250 {
18251         struct alc_spec *spec = codec->spec;
18252         int pin_type = get_pin_type(spec->autocfg.line_out_type);
18253         int i;
18254
18255         for (i = 0; i <= HDA_SIDE; i++) {
18256                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
18257                 if (nid)
18258                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
18259                                         spec->multiout.dac_nids[i]);
18260         }
18261 }
18262
18263 static void alc662_auto_init_hp_out(struct hda_codec *codec)
18264 {
18265         struct alc_spec *spec = codec->spec;
18266         hda_nid_t pin;
18267
18268         pin = spec->autocfg.hp_pins[0];
18269         if (pin)
18270                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
18271                                                   spec->multiout.hp_nid);
18272         pin = spec->autocfg.speaker_pins[0];
18273         if (pin)
18274                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
18275                                         spec->multiout.extra_out_nid[0]);
18276 }
18277
18278 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
18279
18280 static void alc662_auto_init_analog_input(struct hda_codec *codec)
18281 {
18282         struct alc_spec *spec = codec->spec;
18283         int i;
18284
18285         for (i = 0; i < AUTO_PIN_LAST; i++) {
18286                 hda_nid_t nid = spec->autocfg.input_pins[i];
18287                 if (alc_is_input_pin(codec, nid)) {
18288                         alc_set_input_pin(codec, nid, i);
18289                         if (nid != ALC662_PIN_CD_NID &&
18290                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
18291                                 snd_hda_codec_write(codec, nid, 0,
18292                                                     AC_VERB_SET_AMP_GAIN_MUTE,
18293                                                     AMP_OUT_MUTE);
18294                 }
18295         }
18296 }
18297
18298 #define alc662_auto_init_input_src      alc882_auto_init_input_src
18299
18300 static int alc662_parse_auto_config(struct hda_codec *codec)
18301 {
18302         struct alc_spec *spec = codec->spec;
18303         int err;
18304         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
18305
18306         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
18307                                            alc662_ignore);
18308         if (err < 0)
18309                 return err;
18310         if (!spec->autocfg.line_outs)
18311                 return 0; /* can't find valid BIOS pin config */
18312
18313         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
18314         if (err < 0)
18315                 return err;
18316         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
18317         if (err < 0)
18318                 return err;
18319         err = alc662_auto_create_extra_out(codec,
18320                                            spec->autocfg.speaker_pins[0],
18321                                            "Speaker");
18322         if (err < 0)
18323                 return err;
18324         if (err)
18325                 spec->multiout.extra_out_nid[0] = err;
18326         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
18327                                            "Headphone");
18328         if (err < 0)
18329                 return err;
18330         if (err)
18331                 spec->multiout.hp_nid = err;
18332         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
18333         if (err < 0)
18334                 return err;
18335
18336         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
18337
18338         if (spec->autocfg.dig_outs)
18339                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
18340
18341         if (spec->kctls.list)
18342                 add_mixer(spec, spec->kctls.list);
18343
18344         spec->num_mux_defs = 1;
18345         spec->input_mux = &spec->private_imux[0];
18346
18347         add_verb(spec, alc662_init_verbs);
18348         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
18349             codec->vendor_id == 0x10ec0665)
18350                 add_verb(spec, alc663_init_verbs);
18351
18352         if (codec->vendor_id == 0x10ec0272)
18353                 add_verb(spec, alc272_init_verbs);
18354
18355         err = alc_auto_add_mic_boost(codec);
18356         if (err < 0)
18357                 return err;
18358
18359         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
18360             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
18361             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
18362         else
18363             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
18364
18365         return 1;
18366 }
18367
18368 /* additional initialization for auto-configuration model */
18369 static void alc662_auto_init(struct hda_codec *codec)
18370 {
18371         struct alc_spec *spec = codec->spec;
18372         alc662_auto_init_multi_out(codec);
18373         alc662_auto_init_hp_out(codec);
18374         alc662_auto_init_analog_input(codec);
18375         alc662_auto_init_input_src(codec);
18376         if (spec->unsol_event)
18377                 alc_inithook(codec);
18378 }
18379
18380 static int patch_alc662(struct hda_codec *codec)
18381 {
18382         struct alc_spec *spec;
18383         int err, board_config;
18384
18385         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
18386         if (!spec)
18387                 return -ENOMEM;
18388
18389         codec->spec = spec;
18390
18391         alc_fix_pll_init(codec, 0x20, 0x04, 15);
18392
18393         if (alc_read_coef_idx(codec, 0)==0x8020){
18394                 kfree(codec->chip_name);
18395                 codec->chip_name = kstrdup("ALC661", GFP_KERNEL);
18396                 if (!codec->chip_name) {
18397                         alc_free(codec);
18398                         return -ENOMEM;
18399                 }
18400         }
18401
18402         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
18403                                                   alc662_models,
18404                                                   alc662_cfg_tbl);
18405         if (board_config < 0) {
18406                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
18407                        codec->chip_name);
18408                 board_config = ALC662_AUTO;
18409         }
18410
18411         if (board_config == ALC662_AUTO) {
18412                 /* automatic parse from the BIOS config */
18413                 err = alc662_parse_auto_config(codec);
18414                 if (err < 0) {
18415                         alc_free(codec);
18416                         return err;
18417                 } else if (!err) {
18418                         printk(KERN_INFO
18419                                "hda_codec: Cannot set up configuration "
18420                                "from BIOS.  Using base mode...\n");
18421                         board_config = ALC662_3ST_2ch_DIG;
18422                 }
18423         }
18424
18425         err = snd_hda_attach_beep_device(codec, 0x1);
18426         if (err < 0) {
18427                 alc_free(codec);
18428                 return err;
18429         }
18430
18431         if (board_config != ALC662_AUTO)
18432                 setup_preset(codec, &alc662_presets[board_config]);
18433
18434         spec->stream_analog_playback = &alc662_pcm_analog_playback;
18435         spec->stream_analog_capture = &alc662_pcm_analog_capture;
18436
18437         spec->stream_digital_playback = &alc662_pcm_digital_playback;
18438         spec->stream_digital_capture = &alc662_pcm_digital_capture;
18439
18440         if (!spec->adc_nids) {
18441                 spec->adc_nids = alc662_adc_nids;
18442                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
18443         }
18444         if (!spec->capsrc_nids)
18445                 spec->capsrc_nids = alc662_capsrc_nids;
18446
18447         if (!spec->cap_mixer)
18448                 set_capture_mixer(codec);
18449
18450         switch (codec->vendor_id) {
18451         case 0x10ec0662:
18452                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
18453                 break;
18454         case 0x10ec0272:
18455         case 0x10ec0663:
18456         case 0x10ec0665:
18457                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
18458                 break;
18459         case 0x10ec0273:
18460                 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
18461                 break;
18462         }
18463         spec->vmaster_nid = 0x02;
18464
18465         codec->patch_ops = alc_patch_ops;
18466         if (board_config == ALC662_AUTO)
18467                 spec->init_hook = alc662_auto_init;
18468 #ifdef CONFIG_SND_HDA_POWER_SAVE
18469         if (!spec->loopback.amplist)
18470                 spec->loopback.amplist = alc662_loopbacks;
18471 #endif
18472
18473         return 0;
18474 }
18475
18476 static int patch_alc888(struct hda_codec *codec)
18477 {
18478         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
18479                 kfree(codec->chip_name);
18480                 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
18481                 if (!codec->chip_name) {
18482                         alc_free(codec);
18483                         return -ENOMEM;
18484                 }
18485                 return patch_alc662(codec);
18486         }
18487         return patch_alc882(codec);
18488 }
18489
18490 /*
18491  * patch entries
18492  */
18493 static struct hda_codec_preset snd_hda_preset_realtek[] = {
18494         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
18495         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
18496         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
18497         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
18498         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
18499         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
18500         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
18501         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
18502         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
18503           .patch = patch_alc861 },
18504         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
18505         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
18506         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
18507         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
18508           .patch = patch_alc882 },
18509         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
18510           .patch = patch_alc662 },
18511         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
18512         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
18513         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
18514         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
18515         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
18516         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
18517         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
18518           .patch = patch_alc882 },
18519         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
18520           .patch = patch_alc882 },
18521         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
18522         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
18523         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
18524           .patch = patch_alc882 },
18525         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
18526         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
18527         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
18528         {} /* terminator */
18529 };
18530
18531 MODULE_ALIAS("snd-hda-codec-id:10ec*");
18532
18533 MODULE_LICENSE("GPL");
18534 MODULE_DESCRIPTION("Realtek HD-audio codec");
18535
18536 static struct hda_codec_preset_list realtek_list = {
18537         .preset = snd_hda_preset_realtek,
18538         .owner = THIS_MODULE,
18539 };
18540
18541 static int __init patch_realtek_init(void)
18542 {
18543         return snd_hda_add_codec_preset(&realtek_list);
18544 }
18545
18546 static void __exit patch_realtek_exit(void)
18547 {
18548         snd_hda_delete_codec_preset(&realtek_list);
18549 }
18550
18551 module_init(patch_realtek_init)
18552 module_exit(patch_realtek_exit)