sound/pci/hda/patch_realtek.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for ALC 260/880/882 codecs
   5  *
   6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   7  *                    PeiSen Hou <pshou@realtek.com.tw>
   8  *                    Takashi Iwai <tiwai@suse.de>
   9  *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
  10  *
  11  *  This driver is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This driver is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/slab.h>
  29 #include <linux/pci.h>
  30 #include <sound/core.h>
  31 #include "hda_codec.h"
  32 #include "hda_local.h"
  33 #include "hda_beep.h"
  34
  35 #define ALC880_FRONT_EVENT              0x01
  36 #define ALC880_DCVOL_EVENT              0x02
  37 #define ALC880_HP_EVENT                 0x04
  38 #define ALC880_MIC_EVENT                0x08
  39
  40 /* ALC880 board config type */
  41 enum {
  42         ALC880_3ST,
  43         ALC880_3ST_DIG,
  44         ALC880_5ST,
  45         ALC880_5ST_DIG,
  46         ALC880_W810,
  47         ALC880_Z71V,
  48         ALC880_6ST,
  49         ALC880_6ST_DIG,
  50         ALC880_F1734,
  51         ALC880_ASUS,
  52         ALC880_ASUS_DIG,
  53         ALC880_ASUS_W1V,
  54         ALC880_ASUS_DIG2,
  55         ALC880_FUJITSU,
  56         ALC880_UNIWILL_DIG,
  57         ALC880_UNIWILL,
  58         ALC880_UNIWILL_P53,
  59         ALC880_CLEVO,
  60         ALC880_TCL_S700,
  61         ALC880_LG,
  62         ALC880_LG_LW,
  63         ALC880_MEDION_RIM,
  64 #ifdef CONFIG_SND_DEBUG
  65         ALC880_TEST,
  66 #endif
  67         ALC880_AUTO,
  68         ALC880_MODEL_LAST /* last tag */
  69 };
  70
  71 /* ALC260 models */
  72 enum {
  73         ALC260_BASIC,
  74         ALC260_HP,
  75         ALC260_HP_DC7600,
  76         ALC260_HP_3013,
  77         ALC260_FUJITSU_S702X,
  78         ALC260_ACER,
  79         ALC260_WILL,
  80         ALC260_REPLACER_672V,
  81         ALC260_FAVORIT100,
  82 #ifdef CONFIG_SND_DEBUG
  83         ALC260_TEST,
  84 #endif
  85         ALC260_AUTO,
  86         ALC260_MODEL_LAST /* last tag */
  87 };
  88
  89 /* ALC262 models */
  90 enum {
  91         ALC262_BASIC,
  92         ALC262_HIPPO,
  93         ALC262_HIPPO_1,
  94         ALC262_FUJITSU,
  95         ALC262_HP_BPC,
  96         ALC262_HP_BPC_D7000_WL,
  97         ALC262_HP_BPC_D7000_WF,
  98         ALC262_HP_TC_T5735,
  99         ALC262_HP_RP5700,
 100         ALC262_BENQ_ED8,
 101         ALC262_SONY_ASSAMD,
 102         ALC262_BENQ_T31,
 103         ALC262_ULTRA,
 104         ALC262_LENOVO_3000,
 105         ALC262_NEC,
 106         ALC262_TOSHIBA_S06,
 107         ALC262_TOSHIBA_RX1,
 108         ALC262_TYAN,
 109         ALC262_AUTO,
 110         ALC262_MODEL_LAST /* last tag */
 111 };
 112
 113 /* ALC268 models */
 114 enum {
 115         ALC267_QUANTA_IL1,
 116         ALC268_3ST,
 117         ALC268_TOSHIBA,
 118         ALC268_ACER,
 119         ALC268_ACER_DMIC,
 120         ALC268_ACER_ASPIRE_ONE,
 121         ALC268_DELL,
 122         ALC268_ZEPTO,
 123 #ifdef CONFIG_SND_DEBUG
 124         ALC268_TEST,
 125 #endif
 126         ALC268_AUTO,
 127         ALC268_MODEL_LAST /* last tag */
 128 };
 129
 130 /* ALC269 models */
 131 enum {
 132         ALC269_BASIC,
 133         ALC269_QUANTA_FL1,
 134         ALC269_ASUS_EEEPC_P703,
 135         ALC269_ASUS_EEEPC_P901,
 136         ALC269_FUJITSU,
 137         ALC269_LIFEBOOK,
 138         ALC269_AUTO,
 139         ALC269_MODEL_LAST /* last tag */
 140 };
 141
 142 /* ALC861 models */
 143 enum {
 144         ALC861_3ST,
 145         ALC660_3ST,
 146         ALC861_3ST_DIG,
 147         ALC861_6ST_DIG,
 148         ALC861_UNIWILL_M31,
 149         ALC861_TOSHIBA,
 150         ALC861_ASUS,
 151         ALC861_ASUS_LAPTOP,
 152         ALC861_AUTO,
 153         ALC861_MODEL_LAST,
 154 };
 155
 156 /* ALC861-VD models */
 157 enum {
 158         ALC660VD_3ST,
 159         ALC660VD_3ST_DIG,
 160         ALC660VD_ASUS_V1S,
 161         ALC861VD_3ST,
 162         ALC861VD_3ST_DIG,
 163         ALC861VD_6ST_DIG,
 164         ALC861VD_LENOVO,
 165         ALC861VD_DALLAS,
 166         ALC861VD_HP,
 167         ALC861VD_AUTO,
 168         ALC861VD_MODEL_LAST,
 169 };
 170
 171 /* ALC662 models */
 172 enum {
 173         ALC662_3ST_2ch_DIG,
 174         ALC662_3ST_6ch_DIG,
 175         ALC662_3ST_6ch,
 176         ALC662_5ST_DIG,
 177         ALC662_LENOVO_101E,
 178         ALC662_ASUS_EEEPC_P701,
 179         ALC662_ASUS_EEEPC_EP20,
 180         ALC663_ASUS_M51VA,
 181         ALC663_ASUS_G71V,
 182         ALC663_ASUS_H13,
 183         ALC663_ASUS_G50V,
 184         ALC662_ECS,
 185         ALC663_ASUS_MODE1,
 186         ALC662_ASUS_MODE2,
 187         ALC663_ASUS_MODE3,
 188         ALC663_ASUS_MODE4,
 189         ALC663_ASUS_MODE5,
 190         ALC663_ASUS_MODE6,
 191         ALC272_DELL,
 192         ALC272_DELL_ZM1,
 193         ALC272_SAMSUNG_NC10,
 194         ALC662_AUTO,
 195         ALC662_MODEL_LAST,
 196 };
 197
 198 /* ALC882 models */
 199 enum {
 200         ALC882_3ST_DIG,
 201         ALC882_6ST_DIG,
 202         ALC882_ARIMA,
 203         ALC882_W2JC,
 204         ALC882_TARGA,
 205         ALC882_ASUS_A7J,
 206         ALC882_ASUS_A7M,
 207         ALC885_MACPRO,
 208         ALC885_MBP3,
 209         ALC885_MB5,
 210         ALC885_IMAC24,
 211         ALC883_3ST_2ch_DIG,
 212         ALC883_3ST_6ch_DIG,
 213         ALC883_3ST_6ch,
 214         ALC883_6ST_DIG,
 215         ALC883_TARGA_DIG,
 216         ALC883_TARGA_2ch_DIG,
 217         ALC883_TARGA_8ch_DIG,
 218         ALC883_ACER,
 219         ALC883_ACER_ASPIRE,
 220         ALC888_ACER_ASPIRE_4930G,
 221         ALC888_ACER_ASPIRE_6530G,
 222         ALC888_ACER_ASPIRE_8930G,
 223         ALC883_MEDION,
 224         ALC883_MEDION_MD2,
 225         ALC883_LAPTOP_EAPD,
 226         ALC883_LENOVO_101E_2ch,
 227         ALC883_LENOVO_NB0763,
 228         ALC888_LENOVO_MS7195_DIG,
 229         ALC888_LENOVO_SKY,
 230         ALC883_HAIER_W66,
 231         ALC888_3ST_HP,
 232         ALC888_6ST_DELL,
 233         ALC883_MITAC,
 234         ALC883_CLEVO_M720,
 235         ALC883_FUJITSU_PI2515,
 236         ALC888_FUJITSU_XA3530,
 237         ALC883_3ST_6ch_INTEL,
 238         ALC889A_INTEL,
 239         ALC889_INTEL,
 240         ALC888_ASUS_M90V,
 241         ALC888_ASUS_EEE1601,
 242         ALC889A_MB31,
 243         ALC1200_ASUS_P5Q,
 244         ALC883_SONY_VAIO_TT,
 245         ALC882_AUTO,
 246         ALC882_MODEL_LAST,
 247 };
 248
 249 /* for GPIO Poll */
 250 #define GPIO_MASK       0x03
 251
 252 /* extra amp-initialization sequence types */
 253 enum {
 254         ALC_INIT_NONE,
 255         ALC_INIT_DEFAULT,
 256         ALC_INIT_GPIO1,
 257         ALC_INIT_GPIO2,
 258         ALC_INIT_GPIO3,
 259 };
 260
 261 struct alc_spec {
 262         /* codec parameterization */
 263         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 264         unsigned int num_mixers;
 265         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 266         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 267
 268         const struct hda_verb *init_verbs[5];   /* initialization verbs
 269                                                  * don't forget NULL
 270                                                  * termination!
 271                                                  */
 272         unsigned int num_init_verbs;
 273
 274         char stream_name_analog[16];    /* analog PCM stream */
 275         struct hda_pcm_stream *stream_analog_playback;
 276         struct hda_pcm_stream *stream_analog_capture;
 277         struct hda_pcm_stream *stream_analog_alt_playback;
 278         struct hda_pcm_stream *stream_analog_alt_capture;
 279
 280         char stream_name_digital[16];   /* digital PCM stream */
 281         struct hda_pcm_stream *stream_digital_playback;
 282         struct hda_pcm_stream *stream_digital_capture;
 283
 284         /* playback */
 285         struct hda_multi_out multiout;  /* playback set-up
 286                                          * max_channels, dacs must be set
 287                                          * dig_out_nid and hp_nid are optional
 288                                          */
 289         hda_nid_t alt_dac_nid;
 290         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 291         int dig_out_type;
 292
 293         /* capture */
 294         unsigned int num_adc_nids;
 295         hda_nid_t *adc_nids;
 296         hda_nid_t *capsrc_nids;
 297         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 298
 299         /* capture source */
 300         unsigned int num_mux_defs;
 301         const struct hda_input_mux *input_mux;
 302         unsigned int cur_mux[3];
 303
 304         /* channel model */
 305         const struct hda_channel_mode *channel_mode;
 306         int num_channel_mode;
 307         int need_dac_fix;
 308         int const_channel_count;
 309         int ext_channel_count;
 310
 311         /* PCM information */
 312         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 313
 314         /* dynamic controls, init_verbs and input_mux */
 315         struct auto_pin_cfg autocfg;
 316         struct snd_array kctls;
 317         struct hda_input_mux private_imux[3];
 318         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 319         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 320         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 321
 322         /* hooks */
 323         void (*init_hook)(struct hda_codec *codec);
 324         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 325
 326         /* for pin sensing */
 327         unsigned int sense_updated: 1;
 328         unsigned int jack_present: 1;
 329         unsigned int master_sw: 1;
 330
 331         /* other flags */
 332         unsigned int no_analog :1; /* digital I/O only */
 333         int init_amp;
 334
 335         /* for virtual master */
 336         hda_nid_t vmaster_nid;
 337 #ifdef CONFIG_SND_HDA_POWER_SAVE
 338         struct hda_loopback_check loopback;
 339 #endif
 340
 341         /* for PLL fix */
 342         hda_nid_t pll_nid;
 343         unsigned int pll_coef_idx, pll_coef_bit;
 344 };
 345
 346 /*
 347  * configuration template - to be copied to the spec instance
 348  */
 349 struct alc_config_preset {
 350         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 351                                              * with spec
 352                                              */
 353         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 354         const struct hda_verb *init_verbs[5];
 355         unsigned int num_dacs;
 356         hda_nid_t *dac_nids;
 357         hda_nid_t dig_out_nid;          /* optional */
 358         hda_nid_t hp_nid;               /* optional */
 359         hda_nid_t *slave_dig_outs;
 360         unsigned int num_adc_nids;
 361         hda_nid_t *adc_nids;
 362         hda_nid_t *capsrc_nids;
 363         hda_nid_t dig_in_nid;
 364         unsigned int num_channel_mode;
 365         const struct hda_channel_mode *channel_mode;
 366         int need_dac_fix;
 367         int const_channel_count;
 368         unsigned int num_mux_defs;
 369         const struct hda_input_mux *input_mux;
 370         void (*unsol_event)(struct hda_codec *, unsigned int);
 371         void (*init_hook)(struct hda_codec *);
 372 #ifdef CONFIG_SND_HDA_POWER_SAVE
 373         struct hda_amp_list *loopbacks;
 374 #endif
 375 };
 376
 377
 378 /*
 379  * input MUX handling
 380  */
 381 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 382                              struct snd_ctl_elem_info *uinfo)
 383 {
 384         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 385         struct alc_spec *spec = codec->spec;
 386         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 387         if (mux_idx >= spec->num_mux_defs)
 388                 mux_idx = 0;
 389         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 390 }
 391
 392 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 393                             struct snd_ctl_elem_value *ucontrol)
 394 {
 395         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 396         struct alc_spec *spec = codec->spec;
 397         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 398
 399         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 400         return 0;
 401 }
 402
 403 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 404                             struct snd_ctl_elem_value *ucontrol)
 405 {
 406         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 407         struct alc_spec *spec = codec->spec;
 408         const struct hda_input_mux *imux;
 409         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 410         unsigned int mux_idx;
 411         hda_nid_t nid = spec->capsrc_nids ?
 412                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 413         unsigned int type;
 414
 415         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 416         imux = &spec->input_mux[mux_idx];
 417
 418         type = (get_wcaps(codec, nid) & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
 419         if (type == AC_WID_AUD_MIX) {
 420                 /* Matrix-mixer style (e.g. ALC882) */
 421                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 422                 unsigned int i, idx;
 423
 424                 idx = ucontrol->value.enumerated.item[0];
 425                 if (idx >= imux->num_items)
 426                         idx = imux->num_items - 1;
 427                 if (*cur_val == idx)
 428                         return 0;
 429                 for (i = 0; i < imux->num_items; i++) {
 430                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 431                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 432                                                  imux->items[i].index,
 433                                                  HDA_AMP_MUTE, v);
 434                 }
 435                 *cur_val = idx;
 436                 return 1;
 437         } else {
 438                 /* MUX style (e.g. ALC880) */
 439                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 440                                              &spec->cur_mux[adc_idx]);
 441         }
 442 }
 443
 444 /*
 445  * channel mode setting
 446  */
 447 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 448                             struct snd_ctl_elem_info *uinfo)
 449 {
 450         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 451         struct alc_spec *spec = codec->spec;
 452         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 453                                     spec->num_channel_mode);
 454 }
 455
 456 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 457                            struct snd_ctl_elem_value *ucontrol)
 458 {
 459         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 460         struct alc_spec *spec = codec->spec;
 461         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 462                                    spec->num_channel_mode,
 463                                    spec->ext_channel_count);
 464 }
 465
 466 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 467                            struct snd_ctl_elem_value *ucontrol)
 468 {
 469         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 470         struct alc_spec *spec = codec->spec;
 471         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 472                                       spec->num_channel_mode,
 473                                       &spec->ext_channel_count);
 474         if (err >= 0 && !spec->const_channel_count) {
 475                 spec->multiout.max_channels = spec->ext_channel_count;
 476                 if (spec->need_dac_fix)
 477                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 478         }
 479         return err;
 480 }
 481
 482 /*
 483  * Control the mode of pin widget settings via the mixer.  "pc" is used
 484  * instead of "%" to avoid consequences of accidently treating the % as
 485  * being part of a format specifier.  Maximum allowed length of a value is
 486  * 63 characters plus NULL terminator.
 487  *
 488  * Note: some retasking pin complexes seem to ignore requests for input
 489  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 490  * are requested.  Therefore order this list so that this behaviour will not
 491  * cause problems when mixer clients move through the enum sequentially.
 492  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 493  * March 2006.
 494  */
 495 static char *alc_pin_mode_names[] = {
 496         "Mic 50pc bias", "Mic 80pc bias",
 497         "Line in", "Line out", "Headphone out",
 498 };
 499 static unsigned char alc_pin_mode_values[] = {
 500         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 501 };
 502 /* The control can present all 5 options, or it can limit the options based
 503  * in the pin being assumed to be exclusively an input or an output pin.  In
 504  * addition, "input" pins may or may not process the mic bias option
 505  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 506  * accept requests for bias as of chip versions up to March 2006) and/or
 507  * wiring in the computer.
 508  */
 509 #define ALC_PIN_DIR_IN              0x00
 510 #define ALC_PIN_DIR_OUT             0x01
 511 #define ALC_PIN_DIR_INOUT           0x02
 512 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 513 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 514
 515 /* Info about the pin modes supported by the different pin direction modes.
 516  * For each direction the minimum and maximum values are given.
 517  */
 518 static signed char alc_pin_mode_dir_info[5][2] = {
 519         { 0, 2 },    /* ALC_PIN_DIR_IN */
 520         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 521         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 522         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 523         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 524 };
 525 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 526 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 527 #define alc_pin_mode_n_items(_dir) \
 528         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 529
 530 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 531                              struct snd_ctl_elem_info *uinfo)
 532 {
 533         unsigned int item_num = uinfo->value.enumerated.item;
 534         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 535
 536         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 537         uinfo->count = 1;
 538         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 539
 540         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 541                 item_num = alc_pin_mode_min(dir);
 542         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 543         return 0;
 544 }
 545
 546 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 547                             struct snd_ctl_elem_value *ucontrol)
 548 {
 549         unsigned int i;
 550         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 551         hda_nid_t nid = kcontrol->private_value & 0xffff;
 552         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 553         long *valp = ucontrol->value.integer.value;
 554         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 555                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 556                                                  0x00);
 557
 558         /* Find enumerated value for current pinctl setting */
 559         i = alc_pin_mode_min(dir);
 560         while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
 561                 i++;
 562         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 563         return 0;
 564 }
 565
 566 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 567                             struct snd_ctl_elem_value *ucontrol)
 568 {
 569         signed int change;
 570         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 571         hda_nid_t nid = kcontrol->private_value & 0xffff;
 572         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 573         long val = *ucontrol->value.integer.value;
 574         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 575                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 576                                                  0x00);
 577
 578         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 579                 val = alc_pin_mode_min(dir);
 580
 581         change = pinctl != alc_pin_mode_values[val];
 582         if (change) {
 583                 /* Set pin mode to that requested */
 584                 snd_hda_codec_write_cache(codec, nid, 0,
 585                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 586                                           alc_pin_mode_values[val]);
 587
 588                 /* Also enable the retasking pin's input/output as required
 589                  * for the requested pin mode.  Enum values of 2 or less are
 590                  * input modes.
 591                  *
 592                  * Dynamically switching the input/output buffers probably
 593                  * reduces noise slightly (particularly on input) so we'll
 594                  * do it.  However, having both input and output buffers
 595                  * enabled simultaneously doesn't seem to be problematic if
 596                  * this turns out to be necessary in the future.
 597                  */
 598                 if (val <= 2) {
 599                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 600                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 601                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 602                                                  HDA_AMP_MUTE, 0);
 603                 } else {
 604                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 605                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 606                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 607                                                  HDA_AMP_MUTE, 0);
 608                 }
 609         }
 610         return change;
 611 }
 612
 613 #define ALC_PIN_MODE(xname, nid, dir) \
 614         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 615           .info = alc_pin_mode_info, \
 616           .get = alc_pin_mode_get, \
 617           .put = alc_pin_mode_put, \
 618           .private_value = nid | (dir<<16) }
 619
 620 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 621  * together using a mask with more than one bit set.  This control is
 622  * currently used only by the ALC260 test model.  At this stage they are not
 623  * needed for any "production" models.
 624  */
 625 #ifdef CONFIG_SND_DEBUG
 626 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 627
 628 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 629                              struct snd_ctl_elem_value *ucontrol)
 630 {
 631         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 632         hda_nid_t nid = kcontrol->private_value & 0xffff;
 633         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 634         long *valp = ucontrol->value.integer.value;
 635         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 636                                               AC_VERB_GET_GPIO_DATA, 0x00);
 637
 638         *valp = (val & mask) != 0;
 639         return 0;
 640 }
 641 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 642                              struct snd_ctl_elem_value *ucontrol)
 643 {
 644         signed int change;
 645         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 646         hda_nid_t nid = kcontrol->private_value & 0xffff;
 647         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 648         long val = *ucontrol->value.integer.value;
 649         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 650                                                     AC_VERB_GET_GPIO_DATA,
 651                                                     0x00);
 652
 653         /* Set/unset the masked GPIO bit(s) as needed */
 654         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 655         if (val == 0)
 656                 gpio_data &= ~mask;
 657         else
 658                 gpio_data |= mask;
 659         snd_hda_codec_write_cache(codec, nid, 0,
 660                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 661
 662         return change;
 663 }
 664 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 665         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 666           .info = alc_gpio_data_info, \
 667           .get = alc_gpio_data_get, \
 668           .put = alc_gpio_data_put, \
 669           .private_value = nid | (mask<<16) }
 670 #endif   /* CONFIG_SND_DEBUG */
 671
 672 /* A switch control to allow the enabling of the digital IO pins on the
 673  * ALC260.  This is incredibly simplistic; the intention of this control is
 674  * to provide something in the test model allowing digital outputs to be
 675  * identified if present.  If models are found which can utilise these
 676  * outputs a more complete mixer control can be devised for those models if
 677  * necessary.
 678  */
 679 #ifdef CONFIG_SND_DEBUG
 680 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 681
 682 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 683                               struct snd_ctl_elem_value *ucontrol)
 684 {
 685         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 686         hda_nid_t nid = kcontrol->private_value & 0xffff;
 687         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 688         long *valp = ucontrol->value.integer.value;
 689         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 690                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 691
 692         *valp = (val & mask) != 0;
 693         return 0;
 694 }
 695 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 696                               struct snd_ctl_elem_value *ucontrol)
 697 {
 698         signed int change;
 699         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 700         hda_nid_t nid = kcontrol->private_value & 0xffff;
 701         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 702         long val = *ucontrol->value.integer.value;
 703         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 704                                                     AC_VERB_GET_DIGI_CONVERT_1,
 705                                                     0x00);
 706
 707         /* Set/unset the masked control bit(s) as needed */
 708         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 709         if (val==0)
 710                 ctrl_data &= ~mask;
 711         else
 712                 ctrl_data |= mask;
 713         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 714                                   ctrl_data);
 715
 716         return change;
 717 }
 718 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 719         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 720           .info = alc_spdif_ctrl_info, \
 721           .get = alc_spdif_ctrl_get, \
 722           .put = alc_spdif_ctrl_put, \
 723           .private_value = nid | (mask<<16) }
 724 #endif   /* CONFIG_SND_DEBUG */
 725
 726 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 727  * Again, this is only used in the ALC26x test models to help identify when
 728  * the EAPD line must be asserted for features to work.
 729  */
 730 #ifdef CONFIG_SND_DEBUG
 731 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 732
 733 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 734                               struct snd_ctl_elem_value *ucontrol)
 735 {
 736         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 737         hda_nid_t nid = kcontrol->private_value & 0xffff;
 738         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 739         long *valp = ucontrol->value.integer.value;
 740         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 741                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 742
 743         *valp = (val & mask) != 0;
 744         return 0;
 745 }
 746
 747 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 748                               struct snd_ctl_elem_value *ucontrol)
 749 {
 750         int change;
 751         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 752         hda_nid_t nid = kcontrol->private_value & 0xffff;
 753         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 754         long val = *ucontrol->value.integer.value;
 755         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 756                                                     AC_VERB_GET_EAPD_BTLENABLE,
 757                                                     0x00);
 758
 759         /* Set/unset the masked control bit(s) as needed */
 760         change = (!val ? 0 : mask) != (ctrl_data & mask);
 761         if (!val)
 762                 ctrl_data &= ~mask;
 763         else
 764                 ctrl_data |= mask;
 765         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 766                                   ctrl_data);
 767
 768         return change;
 769 }
 770
 771 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 772         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 773           .info = alc_eapd_ctrl_info, \
 774           .get = alc_eapd_ctrl_get, \
 775           .put = alc_eapd_ctrl_put, \
 776           .private_value = nid | (mask<<16) }
 777 #endif   /* CONFIG_SND_DEBUG */
 778
 779 /*
 780  * set up the input pin config (depending on the given auto-pin type)
 781  */
 782 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 783                               int auto_pin_type)
 784 {
 785         unsigned int val = PIN_IN;
 786
 787         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 788                 unsigned int pincap;
 789                 pincap = snd_hda_query_pin_caps(codec, nid);
 790                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 791                 if (pincap & AC_PINCAP_VREF_80)
 792                         val = PIN_VREF80;
 793                 else if (pincap & AC_PINCAP_VREF_50)
 794                         val = PIN_VREF50;
 795                 else if (pincap & AC_PINCAP_VREF_100)
 796                         val = PIN_VREF100;
 797                 else if (pincap & AC_PINCAP_VREF_GRD)
 798                         val = PIN_VREFGRD;
 799         }
 800         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 801 }
 802
 803 /*
 804  */
 805 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 806 {
 807         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 808                 return;
 809         spec->mixers[spec->num_mixers++] = mix;
 810 }
 811
 812 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 813 {
 814         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 815                 return;
 816         spec->init_verbs[spec->num_init_verbs++] = verb;
 817 }
 818
 819 #ifdef CONFIG_PROC_FS
 820 /*
 821  * hook for proc
 822  */
 823 static void print_realtek_coef(struct snd_info_buffer *buffer,
 824                                struct hda_codec *codec, hda_nid_t nid)
 825 {
 826         int coeff;
 827
 828         if (nid != 0x20)
 829                 return;
 830         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 831         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 832         coeff = snd_hda_codec_read(codec, nid, 0,
 833                                    AC_VERB_GET_COEF_INDEX, 0);
 834         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 835 }
 836 #else
 837 #define print_realtek_coef      NULL
 838 #endif
 839
 840 /*
 841  * set up from the preset table
 842  */
 843 static void setup_preset(struct alc_spec *spec,
 844                          const struct alc_config_preset *preset)
 845 {
 846         int i;
 847
 848         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 849                 add_mixer(spec, preset->mixers[i]);
 850         spec->cap_mixer = preset->cap_mixer;
 851         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 852              i++)
 853                 add_verb(spec, preset->init_verbs[i]);
 854
 855         spec->channel_mode = preset->channel_mode;
 856         spec->num_channel_mode = preset->num_channel_mode;
 857         spec->need_dac_fix = preset->need_dac_fix;
 858         spec->const_channel_count = preset->const_channel_count;
 859
 860         if (preset->const_channel_count)
 861                 spec->multiout.max_channels = preset->const_channel_count;
 862         else
 863                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 864         spec->ext_channel_count = spec->channel_mode[0].channels;
 865
 866         spec->multiout.num_dacs = preset->num_dacs;
 867         spec->multiout.dac_nids = preset->dac_nids;
 868         spec->multiout.dig_out_nid = preset->dig_out_nid;
 869         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 870         spec->multiout.hp_nid = preset->hp_nid;
 871
 872         spec->num_mux_defs = preset->num_mux_defs;
 873         if (!spec->num_mux_defs)
 874                 spec->num_mux_defs = 1;
 875         spec->input_mux = preset->input_mux;
 876
 877         spec->num_adc_nids = preset->num_adc_nids;
 878         spec->adc_nids = preset->adc_nids;
 879         spec->capsrc_nids = preset->capsrc_nids;
 880         spec->dig_in_nid = preset->dig_in_nid;
 881
 882         spec->unsol_event = preset->unsol_event;
 883         spec->init_hook = preset->init_hook;
 884 #ifdef CONFIG_SND_HDA_POWER_SAVE
 885         spec->loopback.amplist = preset->loopbacks;
 886 #endif
 887 }
 888
 889 /* Enable GPIO mask and set output */
 890 static struct hda_verb alc_gpio1_init_verbs[] = {
 891         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 892         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 893         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 894         { }
 895 };
 896
 897 static struct hda_verb alc_gpio2_init_verbs[] = {
 898         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 899         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 900         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 901         { }
 902 };
 903
 904 static struct hda_verb alc_gpio3_init_verbs[] = {
 905         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 906         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 907         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 908         { }
 909 };
 910
 911 /*
 912  * Fix hardware PLL issue
 913  * On some codecs, the analog PLL gating control must be off while
 914  * the default value is 1.
 915  */
 916 static void alc_fix_pll(struct hda_codec *codec)
 917 {
 918         struct alc_spec *spec = codec->spec;
 919         unsigned int val;
 920
 921         if (!spec->pll_nid)
 922                 return;
 923         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 924                             spec->pll_coef_idx);
 925         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 926                                  AC_VERB_GET_PROC_COEF, 0);
 927         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 928                             spec->pll_coef_idx);
 929         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 930                             val & ~(1 << spec->pll_coef_bit));
 931 }
 932
 933 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 934                              unsigned int coef_idx, unsigned int coef_bit)
 935 {
 936         struct alc_spec *spec = codec->spec;
 937         spec->pll_nid = nid;
 938         spec->pll_coef_idx = coef_idx;
 939         spec->pll_coef_bit = coef_bit;
 940         alc_fix_pll(codec);
 941 }
 942
 943 static void alc_automute_pin(struct hda_codec *codec)
 944 {
 945         struct alc_spec *spec = codec->spec;
 946         unsigned int present, pincap;
 947         unsigned int nid = spec->autocfg.hp_pins[0];
 948         int i;
 949
 950         pincap = snd_hda_query_pin_caps(codec, nid);
 951         if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
 952                 snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 953         present = snd_hda_codec_read(codec, nid, 0,
 954                                      AC_VERB_GET_PIN_SENSE, 0);
 955         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
 956         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
 957                 nid = spec->autocfg.speaker_pins[i];
 958                 if (!nid)
 959                         break;
 960                 snd_hda_codec_write(codec, nid, 0,
 961                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 962                                     spec->jack_present ? 0 : PIN_OUT);
 963         }
 964 }
 965
 966 #if 0 /* it's broken in some cases -- temporarily disabled */
 967 static void alc_mic_automute(struct hda_codec *codec)
 968 {
 969         struct alc_spec *spec = codec->spec;
 970         unsigned int present;
 971         unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
 972         unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
 973         unsigned int mix_nid = spec->capsrc_nids[0];
 974         unsigned int capsrc_idx_mic, capsrc_idx_fmic;
 975
 976         capsrc_idx_mic = mic_nid - 0x18;
 977         capsrc_idx_fmic = fmic_nid - 0x18;
 978         present = snd_hda_codec_read(codec, mic_nid, 0,
 979                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 980         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 981                     0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
 982         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 983                     0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
 984         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
 985                          HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 986 }
 987 #else
 988 #define alc_mic_automute(codec) do {} while(0) /* NOP */
 989 #endif /* disabled */
 990
 991 /* unsolicited event for HP jack sensing */
 992 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 993 {
 994         if (codec->vendor_id == 0x10ec0880)
 995                 res >>= 28;
 996         else
 997                 res >>= 26;
 998         switch (res) {
 999         case ALC880_HP_EVENT:
1000                 alc_automute_pin(codec);
1001                 break;
1002         case ALC880_MIC_EVENT:
1003                 alc_mic_automute(codec);
1004                 break;
1005         }
1006 }
1007
1008 static void alc_inithook(struct hda_codec *codec)
1009 {
1010         alc_automute_pin(codec);
1011         alc_mic_automute(codec);
1012 }
1013
1014 /* additional initialization for ALC888 variants */
1015 static void alc888_coef_init(struct hda_codec *codec)
1016 {
1017         unsigned int tmp;
1018
1019         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1020         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1021         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1022         if ((tmp & 0xf0) == 0x20)
1023                 /* alc888S-VC */
1024                 snd_hda_codec_read(codec, 0x20, 0,
1025                                    AC_VERB_SET_PROC_COEF, 0x830);
1026          else
1027                  /* alc888-VB */
1028                  snd_hda_codec_read(codec, 0x20, 0,
1029                                     AC_VERB_SET_PROC_COEF, 0x3030);
1030 }
1031
1032 static void alc889_coef_init(struct hda_codec *codec)
1033 {
1034         unsigned int tmp;
1035
1036         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1037         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1038         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1039         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1040 }
1041
1042 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1043 {
1044         unsigned int tmp;
1045
1046         switch (type) {
1047         case ALC_INIT_GPIO1:
1048                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1049                 break;
1050         case ALC_INIT_GPIO2:
1051                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1052                 break;
1053         case ALC_INIT_GPIO3:
1054                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1055                 break;
1056         case ALC_INIT_DEFAULT:
1057                 switch (codec->vendor_id) {
1058                 case 0x10ec0260:
1059                         snd_hda_codec_write(codec, 0x0f, 0,
1060                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1061                         snd_hda_codec_write(codec, 0x10, 0,
1062                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1063                         break;
1064                 case 0x10ec0262:
1065                 case 0x10ec0267:
1066                 case 0x10ec0268:
1067                 case 0x10ec0269:
1068                 case 0x10ec0272:
1069                 case 0x10ec0660:
1070                 case 0x10ec0662:
1071                 case 0x10ec0663:
1072                 case 0x10ec0862:
1073                 case 0x10ec0889:
1074                         snd_hda_codec_write(codec, 0x14, 0,
1075                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1076                         snd_hda_codec_write(codec, 0x15, 0,
1077                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1078                         break;
1079                 }
1080                 switch (codec->vendor_id) {
1081                 case 0x10ec0260:
1082                         snd_hda_codec_write(codec, 0x1a, 0,
1083                                             AC_VERB_SET_COEF_INDEX, 7);
1084                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1085                                                  AC_VERB_GET_PROC_COEF, 0);
1086                         snd_hda_codec_write(codec, 0x1a, 0,
1087                                             AC_VERB_SET_COEF_INDEX, 7);
1088                         snd_hda_codec_write(codec, 0x1a, 0,
1089                                             AC_VERB_SET_PROC_COEF,
1090                                             tmp | 0x2010);
1091                         break;
1092                 case 0x10ec0262:
1093                 case 0x10ec0880:
1094                 case 0x10ec0882:
1095                 case 0x10ec0883:
1096                 case 0x10ec0885:
1097                 case 0x10ec0887:
1098                 case 0x10ec0889:
1099                         alc889_coef_init(codec);
1100                         break;
1101                 case 0x10ec0888:
1102                         alc888_coef_init(codec);
1103                         break;
1104                 case 0x10ec0267:
1105                 case 0x10ec0268:
1106                         snd_hda_codec_write(codec, 0x20, 0,
1107                                             AC_VERB_SET_COEF_INDEX, 7);
1108                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1109                                                  AC_VERB_GET_PROC_COEF, 0);
1110                         snd_hda_codec_write(codec, 0x20, 0,
1111                                             AC_VERB_SET_COEF_INDEX, 7);
1112                         snd_hda_codec_write(codec, 0x20, 0,
1113                                             AC_VERB_SET_PROC_COEF,
1114                                             tmp | 0x3000);
1115                         break;
1116                 }
1117                 break;
1118         }
1119 }
1120
1121 static void alc_init_auto_hp(struct hda_codec *codec)
1122 {
1123         struct alc_spec *spec = codec->spec;
1124
1125         if (!spec->autocfg.hp_pins[0])
1126                 return;
1127
1128         if (!spec->autocfg.speaker_pins[0]) {
1129                 if (spec->autocfg.line_out_pins[0] &&
1130                     spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1131                         spec->autocfg.speaker_pins[0] =
1132                                 spec->autocfg.line_out_pins[0];
1133                 else
1134                         return;
1135         }
1136
1137         snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1138                     spec->autocfg.hp_pins[0]);
1139         snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1140                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1141                                   AC_USRSP_EN | ALC880_HP_EVENT);
1142         spec->unsol_event = alc_sku_unsol_event;
1143 }
1144
1145 /* check subsystem ID and set up device-specific initialization;
1146  * return 1 if initialized, 0 if invalid SSID
1147  */
1148 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1149  *      31 ~ 16 :       Manufacture ID
1150  *      15 ~ 8  :       SKU ID
1151  *      7  ~ 0  :       Assembly ID
1152  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1153  */
1154 static int alc_subsystem_id(struct hda_codec *codec,
1155                             hda_nid_t porta, hda_nid_t porte,
1156                             hda_nid_t portd)
1157 {
1158         unsigned int ass, tmp, i;
1159         unsigned nid;
1160         struct alc_spec *spec = codec->spec;
1161
1162         ass = codec->subsystem_id & 0xffff;
1163         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1164                 goto do_sku;
1165
1166         /* invalid SSID, check the special NID pin defcfg instead */
1167         /*
1168          * 31~30        : port connectivity
1169          * 29~21        : reserve
1170          * 20           : PCBEEP input
1171          * 19~16        : Check sum (15:1)
1172          * 15~1         : Custom
1173          * 0            : override
1174         */
1175         nid = 0x1d;
1176         if (codec->vendor_id == 0x10ec0260)
1177                 nid = 0x17;
1178         ass = snd_hda_codec_get_pincfg(codec, nid);
1179         snd_printd("realtek: No valid SSID, "
1180                    "checking pincfg 0x%08x for NID 0x%x\n",
1181                    ass, nid);
1182         if (!(ass & 1) && !(ass & 0x100000))
1183                 return 0;
1184         if ((ass >> 30) != 1)   /* no physical connection */
1185                 return 0;
1186
1187         /* check sum */
1188         tmp = 0;
1189         for (i = 1; i < 16; i++) {
1190                 if ((ass >> i) & 1)
1191                         tmp++;
1192         }
1193         if (((ass >> 16) & 0xf) != tmp)
1194                 return 0;
1195 do_sku:
1196         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1197                    ass & 0xffff, codec->vendor_id);
1198         /*
1199          * 0 : override
1200          * 1 :  Swap Jack
1201          * 2 : 0 --> Desktop, 1 --> Laptop
1202          * 3~5 : External Amplifier control
1203          * 7~6 : Reserved
1204         */
1205         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1206         switch (tmp) {
1207         case 1:
1208                 spec->init_amp = ALC_INIT_GPIO1;
1209                 break;
1210         case 3:
1211                 spec->init_amp = ALC_INIT_GPIO2;
1212                 break;
1213         case 7:
1214                 spec->init_amp = ALC_INIT_GPIO3;
1215                 break;
1216         case 5:
1217                 spec->init_amp = ALC_INIT_DEFAULT;
1218                 break;
1219         }
1220
1221         /* is laptop or Desktop and enable the function "Mute internal speaker
1222          * when the external headphone out jack is plugged"
1223          */
1224         if (!(ass & 0x8000))
1225                 return 1;
1226         /*
1227          * 10~8 : Jack location
1228          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1229          * 14~13: Resvered
1230          * 15   : 1 --> enable the function "Mute internal speaker
1231          *              when the external headphone out jack is plugged"
1232          */
1233         if (!spec->autocfg.hp_pins[0]) {
1234                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1235                 if (tmp == 0)
1236                         spec->autocfg.hp_pins[0] = porta;
1237                 else if (tmp == 1)
1238                         spec->autocfg.hp_pins[0] = porte;
1239                 else if (tmp == 2)
1240                         spec->autocfg.hp_pins[0] = portd;
1241                 else
1242                         return 1;
1243         }
1244
1245         alc_init_auto_hp(codec);
1246         return 1;
1247 }
1248
1249 static void alc_ssid_check(struct hda_codec *codec,
1250                            hda_nid_t porta, hda_nid_t porte, hda_nid_t portd)
1251 {
1252         if (!alc_subsystem_id(codec, porta, porte, portd)) {
1253                 struct alc_spec *spec = codec->spec;
1254                 snd_printd("realtek: "
1255                            "Enable default setup for auto mode as fallback\n");
1256                 spec->init_amp = ALC_INIT_DEFAULT;
1257                 alc_init_auto_hp(codec);
1258         }
1259 }
1260
1261 /*
1262  * Fix-up pin default configurations
1263  */
1264
1265 struct alc_pincfg {
1266         hda_nid_t nid;
1267         u32 val;
1268 };
1269
1270 static void alc_fix_pincfg(struct hda_codec *codec,
1271                            const struct snd_pci_quirk *quirk,
1272                            const struct alc_pincfg **pinfix)
1273 {
1274         const struct alc_pincfg *cfg;
1275
1276         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1277         if (!quirk)
1278                 return;
1279
1280         cfg = pinfix[quirk->value];
1281         for (; cfg->nid; cfg++)
1282                 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1283 }
1284
1285 /*
1286  * ALC888
1287  */
1288
1289 /*
1290  * 2ch mode
1291  */
1292 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1293 /* Mic-in jack as mic in */
1294         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1295         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1296 /* Line-in jack as Line in */
1297         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1298         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1299 /* Line-Out as Front */
1300         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1301         { } /* end */
1302 };
1303
1304 /*
1305  * 4ch mode
1306  */
1307 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1308 /* Mic-in jack as mic in */
1309         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1310         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1311 /* Line-in jack as Surround */
1312         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1313         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1314 /* Line-Out as Front */
1315         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1316         { } /* end */
1317 };
1318
1319 /*
1320  * 6ch mode
1321  */
1322 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1323 /* Mic-in jack as CLFE */
1324         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1325         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1326 /* Line-in jack as Surround */
1327         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1328         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1329 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1330         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1331         { } /* end */
1332 };
1333
1334 /*
1335  * 8ch mode
1336  */
1337 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1338 /* Mic-in jack as CLFE */
1339         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1340         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1341 /* Line-in jack as Surround */
1342         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1343         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1344 /* Line-Out as Side */
1345         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1346         { } /* end */
1347 };
1348
1349 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1350         { 2, alc888_4ST_ch2_intel_init },
1351         { 4, alc888_4ST_ch4_intel_init },
1352         { 6, alc888_4ST_ch6_intel_init },
1353         { 8, alc888_4ST_ch8_intel_init },
1354 };
1355
1356 /*
1357  * ALC888 Fujitsu Siemens Amillo xa3530
1358  */
1359
1360 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1361 /* Front Mic: set to PIN_IN (empty by default) */
1362         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1363 /* Connect Internal HP to Front */
1364         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1365         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1366         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1367 /* Connect Bass HP to Front */
1368         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1369         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1370         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1371 /* Connect Line-Out side jack (SPDIF) to Side */
1372         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1373         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1374         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1375 /* Connect Mic jack to CLFE */
1376         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1377         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1378         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1379 /* Connect Line-in jack to Surround */
1380         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1381         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1382         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1383 /* Connect HP out jack to Front */
1384         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1385         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1386         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1387 /* Enable unsolicited event for HP jack and Line-out jack */
1388         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1389         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1390         {}
1391 };
1392
1393 static void alc_automute_amp(struct hda_codec *codec)
1394 {
1395         struct alc_spec *spec = codec->spec;
1396         unsigned int val, mute, pincap;
1397         hda_nid_t nid;
1398         int i;
1399
1400         spec->jack_present = 0;
1401         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1402                 nid = spec->autocfg.hp_pins[i];
1403                 if (!nid)
1404                         break;
1405                 pincap = snd_hda_query_pin_caps(codec, nid);
1406                 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
1407                         snd_hda_codec_read(codec, nid, 0,
1408                                            AC_VERB_SET_PIN_SENSE, 0);
1409                 val = snd_hda_codec_read(codec, nid, 0,
1410                                          AC_VERB_GET_PIN_SENSE, 0);
1411                 if (val & AC_PINSENSE_PRESENCE) {
1412                         spec->jack_present = 1;
1413                         break;
1414                 }
1415         }
1416
1417         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1418         /* Toggle internal speakers muting */
1419         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1420                 nid = spec->autocfg.speaker_pins[i];
1421                 if (!nid)
1422                         break;
1423                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1424                                          HDA_AMP_MUTE, mute);
1425         }
1426 }
1427
1428 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1429                                          unsigned int res)
1430 {
1431         if (codec->vendor_id == 0x10ec0880)
1432                 res >>= 28;
1433         else
1434                 res >>= 26;
1435         if (res == ALC880_HP_EVENT)
1436                 alc_automute_amp(codec);
1437 }
1438
1439 static void alc888_fujitsu_xa3530_init_hook(struct hda_codec *codec)
1440 {
1441         struct alc_spec *spec = codec->spec;
1442
1443         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1444         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1445         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1446         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1447         alc_automute_amp(codec);
1448 }
1449
1450 /*
1451  * ALC888 Acer Aspire 4930G model
1452  */
1453
1454 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1455 /* Front Mic: set to PIN_IN (empty by default) */
1456         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1457 /* Unselect Front Mic by default in input mixer 3 */
1458         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1459 /* Enable unsolicited event for HP jack */
1460         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1461 /* Connect Internal HP to front */
1462         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1463         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1464         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1465 /* Connect HP out to front */
1466         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1467         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1468         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1469         { }
1470 };
1471
1472 /*
1473  * ALC888 Acer Aspire 6530G model
1474  */
1475
1476 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1477 /* Bias voltage on for external mic port */
1478         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1479 /* Front Mic: set to PIN_IN (empty by default) */
1480         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1481 /* Unselect Front Mic by default in input mixer 3 */
1482         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1483 /* Enable unsolicited event for HP jack */
1484         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1485 /* Enable speaker output */
1486         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1487         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1488 /* Enable headphone output */
1489         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1490         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1491         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1492         { }
1493 };
1494
1495 /*
1496  * ALC889 Acer Aspire 8930G model
1497  */
1498
1499 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1500 /* Front Mic: set to PIN_IN (empty by default) */
1501         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1502 /* Unselect Front Mic by default in input mixer 3 */
1503         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1504 /* Enable unsolicited event for HP jack */
1505         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1506 /* Connect Internal Front to Front */
1507         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1508         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1509         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1510 /* Connect Internal Rear to Rear */
1511         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1512         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1513         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1514 /* Connect Internal CLFE to CLFE */
1515         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1516         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1517         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1518 /* Connect HP out to Front */
1519         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1520         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1521         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1522 /* Enable all DACs */
1523 /*  DAC DISABLE/MUTE 1? */
1524 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
1525         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
1526         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1527 /*  DAC DISABLE/MUTE 2? */
1528 /*  some bit here disables the other DACs. Init=0x4900 */
1529         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
1530         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1531 /* Enable amplifiers */
1532         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
1533         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
1534 /* DMIC fix
1535  * This laptop has a stereo digital microphone. The mics are only 1cm apart
1536  * which makes the stereo useless. However, either the mic or the ALC889
1537  * makes the signal become a difference/sum signal instead of standard
1538  * stereo, which is annoying. So instead we flip this bit which makes the
1539  * codec replicate the sum signal to both channels, turning it into a
1540  * normal mono mic.
1541  */
1542 /*  DMIC_CONTROL? Init value = 0x0001 */
1543         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
1544         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
1545         { }
1546 };
1547
1548 static struct hda_input_mux alc888_2_capture_sources[2] = {
1549         /* Front mic only available on one ADC */
1550         {
1551                 .num_items = 4,
1552                 .items = {
1553                         { "Mic", 0x0 },
1554                         { "Line", 0x2 },
1555                         { "CD", 0x4 },
1556                         { "Front Mic", 0xb },
1557                 },
1558         },
1559         {
1560                 .num_items = 3,
1561                 .items = {
1562                         { "Mic", 0x0 },
1563                         { "Line", 0x2 },
1564                         { "CD", 0x4 },
1565                 },
1566         }
1567 };
1568
1569 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
1570         /* Interal mic only available on one ADC */
1571         {
1572                 .num_items = 5,
1573                 .items = {
1574                         { "Ext Mic", 0x0 },
1575                         { "Line In", 0x2 },
1576                         { "CD", 0x4 },
1577                         { "Input Mix", 0xa },
1578                         { "Int Mic", 0xb },
1579                 },
1580         },
1581         {
1582                 .num_items = 4,
1583                 .items = {
1584                         { "Ext Mic", 0x0 },
1585                         { "Line In", 0x2 },
1586                         { "CD", 0x4 },
1587                         { "Input Mix", 0xa },
1588                 },
1589         }
1590 };
1591
1592 static struct hda_input_mux alc889_capture_sources[3] = {
1593         /* Digital mic only available on first "ADC" */
1594         {
1595                 .num_items = 5,
1596                 .items = {
1597                         { "Mic", 0x0 },
1598                         { "Line", 0x2 },
1599                         { "CD", 0x4 },
1600                         { "Front Mic", 0xb },
1601                         { "Input Mix", 0xa },
1602                 },
1603         },
1604         {
1605                 .num_items = 4,
1606                 .items = {
1607                         { "Mic", 0x0 },
1608                         { "Line", 0x2 },
1609                         { "CD", 0x4 },
1610                         { "Input Mix", 0xa },
1611                 },
1612         },
1613         {
1614                 .num_items = 4,
1615                 .items = {
1616                         { "Mic", 0x0 },
1617                         { "Line", 0x2 },
1618                         { "CD", 0x4 },
1619                         { "Input Mix", 0xa },
1620                 },
1621         }
1622 };
1623
1624 static struct snd_kcontrol_new alc888_base_mixer[] = {
1625         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1626         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1627         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1628         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1629         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1630                 HDA_OUTPUT),
1631         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1632         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1633         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1634         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1635         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1636         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1637         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1638         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1639         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1640         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1641         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1642         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1643         { } /* end */
1644 };
1645
1646 static void alc888_acer_aspire_4930g_init_hook(struct hda_codec *codec)
1647 {
1648         struct alc_spec *spec = codec->spec;
1649
1650         spec->autocfg.hp_pins[0] = 0x15;
1651         spec->autocfg.speaker_pins[0] = 0x14;
1652         alc_automute_amp(codec);
1653 }
1654
1655 static void alc888_acer_aspire_6530g_init_hook(struct hda_codec *codec)
1656 {
1657         struct alc_spec *spec = codec->spec;
1658
1659         spec->autocfg.hp_pins[0] = 0x15;
1660         spec->autocfg.speaker_pins[0] = 0x14;
1661         spec->autocfg.speaker_pins[1] = 0x16;
1662         spec->autocfg.speaker_pins[2] = 0x17;
1663         alc_automute_amp(codec);
1664 }
1665
1666 static void alc889_acer_aspire_8930g_init_hook(struct hda_codec *codec)
1667 {
1668         struct alc_spec *spec = codec->spec;
1669
1670         spec->autocfg.hp_pins[0] = 0x15;
1671         spec->autocfg.speaker_pins[0] = 0x14;
1672         spec->autocfg.speaker_pins[1] = 0x16;
1673         spec->autocfg.speaker_pins[2] = 0x1b;
1674         alc_automute_amp(codec);
1675 }
1676
1677 /*
1678  * ALC880 3-stack model
1679  *
1680  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1681  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1682  *                 F-Mic = 0x1b, HP = 0x19
1683  */
1684
1685 static hda_nid_t alc880_dac_nids[4] = {
1686         /* front, rear, clfe, rear_surr */
1687         0x02, 0x05, 0x04, 0x03
1688 };
1689
1690 static hda_nid_t alc880_adc_nids[3] = {
1691         /* ADC0-2 */
1692         0x07, 0x08, 0x09,
1693 };
1694
1695 /* The datasheet says the node 0x07 is connected from inputs,
1696  * but it shows zero connection in the real implementation on some devices.
1697  * Note: this is a 915GAV bug, fixed on 915GLV
1698  */
1699 static hda_nid_t alc880_adc_nids_alt[2] = {
1700         /* ADC1-2 */
1701         0x08, 0x09,
1702 };
1703
1704 #define ALC880_DIGOUT_NID       0x06
1705 #define ALC880_DIGIN_NID        0x0a
1706
1707 static struct hda_input_mux alc880_capture_source = {
1708         .num_items = 4,
1709         .items = {
1710                 { "Mic", 0x0 },
1711                 { "Front Mic", 0x3 },
1712                 { "Line", 0x2 },
1713                 { "CD", 0x4 },
1714         },
1715 };
1716
1717 /* channel source setting (2/6 channel selection for 3-stack) */
1718 /* 2ch mode */
1719 static struct hda_verb alc880_threestack_ch2_init[] = {
1720         /* set line-in to input, mute it */
1721         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1722         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1723         /* set mic-in to input vref 80%, mute it */
1724         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1725         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1726         { } /* end */
1727 };
1728
1729 /* 6ch mode */
1730 static struct hda_verb alc880_threestack_ch6_init[] = {
1731         /* set line-in to output, unmute it */
1732         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1733         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1734         /* set mic-in to output, unmute it */
1735         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1736         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1737         { } /* end */
1738 };
1739
1740 static struct hda_channel_mode alc880_threestack_modes[2] = {
1741         { 2, alc880_threestack_ch2_init },
1742         { 6, alc880_threestack_ch6_init },
1743 };
1744
1745 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1746         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1747         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1748         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1749         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1750         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1751         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1752         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1753         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1754         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1755         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1756         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1757         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1758         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1759         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1760         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1761         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1762         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1763         {
1764                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1765                 .name = "Channel Mode",
1766                 .info = alc_ch_mode_info,
1767                 .get = alc_ch_mode_get,
1768                 .put = alc_ch_mode_put,
1769         },
1770         { } /* end */
1771 };
1772
1773 /* capture mixer elements */
1774 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1775                             struct snd_ctl_elem_info *uinfo)
1776 {
1777         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1778         struct alc_spec *spec = codec->spec;
1779         int err;
1780
1781         mutex_lock(&codec->control_mutex);
1782         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1783                                                       HDA_INPUT);
1784         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1785         mutex_unlock(&codec->control_mutex);
1786         return err;
1787 }
1788
1789 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1790                            unsigned int size, unsigned int __user *tlv)
1791 {
1792         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1793         struct alc_spec *spec = codec->spec;
1794         int err;
1795
1796         mutex_lock(&codec->control_mutex);
1797         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1798                                                       HDA_INPUT);
1799         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1800         mutex_unlock(&codec->control_mutex);
1801         return err;
1802 }
1803
1804 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1805                              struct snd_ctl_elem_value *ucontrol);
1806
1807 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1808                                  struct snd_ctl_elem_value *ucontrol,
1809                                  getput_call_t func)
1810 {
1811         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1812         struct alc_spec *spec = codec->spec;
1813         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1814         int err;
1815
1816         mutex_lock(&codec->control_mutex);
1817         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1818                                                       3, 0, HDA_INPUT);
1819         err = func(kcontrol, ucontrol);
1820         mutex_unlock(&codec->control_mutex);
1821         return err;
1822 }
1823
1824 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1825                            struct snd_ctl_elem_value *ucontrol)
1826 {
1827         return alc_cap_getput_caller(kcontrol, ucontrol,
1828                                      snd_hda_mixer_amp_volume_get);
1829 }
1830
1831 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1832                            struct snd_ctl_elem_value *ucontrol)
1833 {
1834         return alc_cap_getput_caller(kcontrol, ucontrol,
1835                                      snd_hda_mixer_amp_volume_put);
1836 }
1837
1838 /* capture mixer elements */
1839 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1840
1841 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1842                           struct snd_ctl_elem_value *ucontrol)
1843 {
1844         return alc_cap_getput_caller(kcontrol, ucontrol,
1845                                      snd_hda_mixer_amp_switch_get);
1846 }
1847
1848 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1849                           struct snd_ctl_elem_value *ucontrol)
1850 {
1851         return alc_cap_getput_caller(kcontrol, ucontrol,
1852                                      snd_hda_mixer_amp_switch_put);
1853 }
1854
1855 #define _DEFINE_CAPMIX(num) \
1856         { \
1857                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1858                 .name = "Capture Switch", \
1859                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1860                 .count = num, \
1861                 .info = alc_cap_sw_info, \
1862                 .get = alc_cap_sw_get, \
1863                 .put = alc_cap_sw_put, \
1864         }, \
1865         { \
1866                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1867                 .name = "Capture Volume", \
1868                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1869                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1870                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1871                 .count = num, \
1872                 .info = alc_cap_vol_info, \
1873                 .get = alc_cap_vol_get, \
1874                 .put = alc_cap_vol_put, \
1875                 .tlv = { .c = alc_cap_vol_tlv }, \
1876         }
1877
1878 #define _DEFINE_CAPSRC(num) \
1879         { \
1880                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1881                 /* .name = "Capture Source", */ \
1882                 .name = "Input Source", \
1883                 .count = num, \
1884                 .info = alc_mux_enum_info, \
1885                 .get = alc_mux_enum_get, \
1886                 .put = alc_mux_enum_put, \
1887         }
1888
1889 #define DEFINE_CAPMIX(num) \
1890 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1891         _DEFINE_CAPMIX(num),                                  \
1892         _DEFINE_CAPSRC(num),                                  \
1893         { } /* end */                                         \
1894 }
1895
1896 #define DEFINE_CAPMIX_NOSRC(num) \
1897 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1898         _DEFINE_CAPMIX(num),                                        \
1899         { } /* end */                                               \
1900 }
1901
1902 /* up to three ADCs */
1903 DEFINE_CAPMIX(1);
1904 DEFINE_CAPMIX(2);
1905 DEFINE_CAPMIX(3);
1906 DEFINE_CAPMIX_NOSRC(1);
1907 DEFINE_CAPMIX_NOSRC(2);
1908 DEFINE_CAPMIX_NOSRC(3);
1909
1910 /*
1911  * ALC880 5-stack model
1912  *
1913  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1914  *      Side = 0x02 (0xd)
1915  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1916  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1917  */
1918
1919 /* additional mixers to alc880_three_stack_mixer */
1920 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1921         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1922         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1923         { } /* end */
1924 };
1925
1926 /* channel source setting (6/8 channel selection for 5-stack) */
1927 /* 6ch mode */
1928 static struct hda_verb alc880_fivestack_ch6_init[] = {
1929         /* set line-in to input, mute it */
1930         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1931         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1932         { } /* end */
1933 };
1934
1935 /* 8ch mode */
1936 static struct hda_verb alc880_fivestack_ch8_init[] = {
1937         /* set line-in to output, unmute it */
1938         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1939         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1940         { } /* end */
1941 };
1942
1943 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1944         { 6, alc880_fivestack_ch6_init },
1945         { 8, alc880_fivestack_ch8_init },
1946 };
1947
1948
1949 /*
1950  * ALC880 6-stack model
1951  *
1952  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1953  *      Side = 0x05 (0x0f)
1954  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1955  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1956  */
1957
1958 static hda_nid_t alc880_6st_dac_nids[4] = {
1959         /* front, rear, clfe, rear_surr */
1960         0x02, 0x03, 0x04, 0x05
1961 };
1962
1963 static struct hda_input_mux alc880_6stack_capture_source = {
1964         .num_items = 4,
1965         .items = {
1966                 { "Mic", 0x0 },
1967                 { "Front Mic", 0x1 },
1968                 { "Line", 0x2 },
1969                 { "CD", 0x4 },
1970         },
1971 };
1972
1973 /* fixed 8-channels */
1974 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1975         { 8, NULL },
1976 };
1977
1978 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1979         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1980         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1981         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1982         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1983         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1984         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1985         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1986         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1987         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1988         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1989         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1990         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1991         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1992         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1993         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1994         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1995         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1996         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1997         {
1998                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1999                 .name = "Channel Mode",
2000                 .info = alc_ch_mode_info,
2001                 .get = alc_ch_mode_get,
2002                 .put = alc_ch_mode_put,
2003         },
2004         { } /* end */
2005 };
2006
2007
2008 /*
2009  * ALC880 W810 model
2010  *
2011  * W810 has rear IO for:
2012  * Front (DAC 02)
2013  * Surround (DAC 03)
2014  * Center/LFE (DAC 04)
2015  * Digital out (06)
2016  *
2017  * The system also has a pair of internal speakers, and a headphone jack.
2018  * These are both connected to Line2 on the codec, hence to DAC 02.
2019  *
2020  * There is a variable resistor to control the speaker or headphone
2021  * volume. This is a hardware-only device without a software API.
2022  *
2023  * Plugging headphones in will disable the internal speakers. This is
2024  * implemented in hardware, not via the driver using jack sense. In
2025  * a similar fashion, plugging into the rear socket marked "front" will
2026  * disable both the speakers and headphones.
2027  *
2028  * For input, there's a microphone jack, and an "audio in" jack.
2029  * These may not do anything useful with this driver yet, because I
2030  * haven't setup any initialization verbs for these yet...
2031  */
2032
2033 static hda_nid_t alc880_w810_dac_nids[3] = {
2034         /* front, rear/surround, clfe */
2035         0x02, 0x03, 0x04
2036 };
2037
2038 /* fixed 6 channels */
2039 static struct hda_channel_mode alc880_w810_modes[1] = {
2040         { 6, NULL }
2041 };
2042
2043 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2044 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2045         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2046         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2047         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2048         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2049         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2050         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2051         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2052         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2053         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2054         { } /* end */
2055 };
2056
2057
2058 /*
2059  * Z710V model
2060  *
2061  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2062  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2063  *                 Line = 0x1a
2064  */
2065
2066 static hda_nid_t alc880_z71v_dac_nids[1] = {
2067         0x02
2068 };
2069 #define ALC880_Z71V_HP_DAC      0x03
2070
2071 /* fixed 2 channels */
2072 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2073         { 2, NULL }
2074 };
2075
2076 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2077         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2078         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2079         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2080         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2081         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2082         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2083         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2084         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2085         { } /* end */
2086 };
2087
2088
2089 /*
2090  * ALC880 F1734 model
2091  *
2092  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2093  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2094  */
2095
2096 static hda_nid_t alc880_f1734_dac_nids[1] = {
2097         0x03
2098 };
2099 #define ALC880_F1734_HP_DAC     0x02
2100
2101 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2102         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2103         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2104         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2105         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2106         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2107         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2108         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2109         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2110         { } /* end */
2111 };
2112
2113 static struct hda_input_mux alc880_f1734_capture_source = {
2114         .num_items = 2,
2115         .items = {
2116                 { "Mic", 0x1 },
2117                 { "CD", 0x4 },
2118         },
2119 };
2120
2121
2122 /*
2123  * ALC880 ASUS model
2124  *
2125  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2126  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2127  *  Mic = 0x18, Line = 0x1a
2128  */
2129
2130 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2131 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2132
2133 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2134         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2135         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2136         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2137         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2138         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2139         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2140         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2141         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2142         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2143         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2144         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2145         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2146         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2147         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2148         {
2149                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2150                 .name = "Channel Mode",
2151                 .info = alc_ch_mode_info,
2152                 .get = alc_ch_mode_get,
2153                 .put = alc_ch_mode_put,
2154         },
2155         { } /* end */
2156 };
2157
2158 /*
2159  * ALC880 ASUS W1V model
2160  *
2161  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2162  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2163  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2164  */
2165
2166 /* additional mixers to alc880_asus_mixer */
2167 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2168         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2169         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2170         { } /* end */
2171 };
2172
2173 /* TCL S700 */
2174 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2175         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2176         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2177         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2178         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2179         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2180         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2181         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2182         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2183         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2184         { } /* end */
2185 };
2186
2187 /* Uniwill */
2188 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2189         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2190         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2191         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2192         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2193         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2194         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2195         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2196         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2197         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2198         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2199         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2200         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2201         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2202         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2203         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2204         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2205         {
2206                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2207                 .name = "Channel Mode",
2208                 .info = alc_ch_mode_info,
2209                 .get = alc_ch_mode_get,
2210                 .put = alc_ch_mode_put,
2211         },
2212         { } /* end */
2213 };
2214
2215 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2216         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2217         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2218         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2219         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2220         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2221         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2222         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2223         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2224         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2225         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2226         { } /* end */
2227 };
2228
2229 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2230         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2231         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2232         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2233         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2234         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2235         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2236         { } /* end */
2237 };
2238
2239 /*
2240  * virtual master controls
2241  */
2242
2243 /*
2244  * slave controls for virtual master
2245  */
2246 static const char *alc_slave_vols[] = {
2247         "Front Playback Volume",
2248         "Surround Playback Volume",
2249         "Center Playback Volume",
2250         "LFE Playback Volume",
2251         "Side Playback Volume",
2252         "Headphone Playback Volume",
2253         "Speaker Playback Volume",
2254         "Mono Playback Volume",
2255         "Line-Out Playback Volume",
2256         "PCM Playback Volume",
2257         NULL,
2258 };
2259
2260 static const char *alc_slave_sws[] = {
2261         "Front Playback Switch",
2262         "Surround Playback Switch",
2263         "Center Playback Switch",
2264         "LFE Playback Switch",
2265         "Side Playback Switch",
2266         "Headphone Playback Switch",
2267         "Speaker Playback Switch",
2268         "Mono Playback Switch",
2269         "IEC958 Playback Switch",
2270         NULL,
2271 };
2272
2273 /*
2274  * build control elements
2275  */
2276
2277 static void alc_free_kctls(struct hda_codec *codec);
2278
2279 /* additional beep mixers; the actual parameters are overwritten at build */
2280 static struct snd_kcontrol_new alc_beep_mixer[] = {
2281         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2282         HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
2283         { } /* end */
2284 };
2285
2286 static int alc_build_controls(struct hda_codec *codec)
2287 {
2288         struct alc_spec *spec = codec->spec;
2289         int err;
2290         int i;
2291
2292         for (i = 0; i < spec->num_mixers; i++) {
2293                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2294                 if (err < 0)
2295                         return err;
2296         }
2297         if (spec->cap_mixer) {
2298                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2299                 if (err < 0)
2300                         return err;
2301         }
2302         if (spec->multiout.dig_out_nid) {
2303                 err = snd_hda_create_spdif_out_ctls(codec,
2304                                                     spec->multiout.dig_out_nid);
2305                 if (err < 0)
2306                         return err;
2307                 if (!spec->no_analog) {
2308                         err = snd_hda_create_spdif_share_sw(codec,
2309                                                             &spec->multiout);
2310                         if (err < 0)
2311                                 return err;
2312                         spec->multiout.share_spdif = 1;
2313                 }
2314         }
2315         if (spec->dig_in_nid) {
2316                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2317                 if (err < 0)
2318                         return err;
2319         }
2320
2321         /* create beep controls if needed */
2322         if (spec->beep_amp) {
2323                 struct snd_kcontrol_new *knew;
2324                 for (knew = alc_beep_mixer; knew->name; knew++) {
2325                         struct snd_kcontrol *kctl;
2326                         kctl = snd_ctl_new1(knew, codec);
2327                         if (!kctl)
2328                                 return -ENOMEM;
2329                         kctl->private_value = spec->beep_amp;
2330                         err = snd_hda_ctl_add(codec, kctl);
2331                         if (err < 0)
2332                                 return err;
2333                 }
2334         }
2335
2336         /* if we have no master control, let's create it */
2337         if (!spec->no_analog &&
2338             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2339                 unsigned int vmaster_tlv[4];
2340                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2341                                         HDA_OUTPUT, vmaster_tlv);
2342                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2343                                           vmaster_tlv, alc_slave_vols);
2344                 if (err < 0)
2345                         return err;
2346         }
2347         if (!spec->no_analog &&
2348             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2349                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2350                                           NULL, alc_slave_sws);
2351                 if (err < 0)
2352                         return err;
2353         }
2354
2355         alc_free_kctls(codec); /* no longer needed */
2356         return 0;
2357 }
2358
2359
2360 /*
2361  * initialize the codec volumes, etc
2362  */
2363
2364 /*
2365  * generic initialization of ADC, input mixers and output mixers
2366  */
2367 static struct hda_verb alc880_volume_init_verbs[] = {
2368         /*
2369          * Unmute ADC0-2 and set the default input to mic-in
2370          */
2371         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2372         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2373         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2374         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2375         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2376         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2377
2378         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2379          * mixer widget
2380          * Note: PASD motherboards uses the Line In 2 as the input for front
2381          * panel mic (mic 2)
2382          */
2383         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2384         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2385         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2386         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2387         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2388         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2389         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2390         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2391
2392         /*
2393          * Set up output mixers (0x0c - 0x0f)
2394          */
2395         /* set vol=0 to output mixers */
2396         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2397         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2398         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2399         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2400         /* set up input amps for analog loopback */
2401         /* Amp Indices: DAC = 0, mixer = 1 */
2402         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2403         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2404         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2405         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2406         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2407         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2408         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2409         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2410
2411         { }
2412 };
2413
2414 /*
2415  * 3-stack pin configuration:
2416  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2417  */
2418 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2419         /*
2420          * preset connection lists of input pins
2421          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2422          */
2423         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2424         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2425         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2426
2427         /*
2428          * Set pin mode and muting
2429          */
2430         /* set front pin widgets 0x14 for output */
2431         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2432         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2433         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2434         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2435         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2436         /* Mic2 (as headphone out) for HP output */
2437         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2438         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2439         /* Line In pin widget for input */
2440         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2441         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2442         /* Line2 (as front mic) pin widget for input and vref at 80% */
2443         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2444         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2445         /* CD pin widget for input */
2446         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2447
2448         { }
2449 };
2450
2451 /*
2452  * 5-stack pin configuration:
2453  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2454  * line-in/side = 0x1a, f-mic = 0x1b
2455  */
2456 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2457         /*
2458          * preset connection lists of input pins
2459          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2460          */
2461         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2462         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2463
2464         /*
2465          * Set pin mode and muting
2466          */
2467         /* set pin widgets 0x14-0x17 for output */
2468         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2469         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2470         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2471         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2472         /* unmute pins for output (no gain on this amp) */
2473         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2474         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2475         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2476         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2477
2478         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2479         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2480         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2481         /* Mic2 (as headphone out) for HP output */
2482         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2483         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2484         /* Line In pin widget for input */
2485         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2486         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2487         /* Line2 (as front mic) pin widget for input and vref at 80% */
2488         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2489         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2490         /* CD pin widget for input */
2491         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2492
2493         { }
2494 };
2495
2496 /*
2497  * W810 pin configuration:
2498  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2499  */
2500 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2501         /* hphone/speaker input selector: front DAC */
2502         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2503
2504         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2505         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2506         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2507         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2508         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2509         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2510
2511         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2512         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2513
2514         { }
2515 };
2516
2517 /*
2518  * Z71V pin configuration:
2519  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2520  */
2521 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2522         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2523         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2524         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2525         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2526
2527         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2528         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2529         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2530         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2531
2532         { }
2533 };
2534
2535 /*
2536  * 6-stack pin configuration:
2537  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2538  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2539  */
2540 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2541         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2542
2543         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2544         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2545         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2546         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2547         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2548         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2549         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2550         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2551
2552         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2553         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2554         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2555         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2556         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2557         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2558         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2559         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2560         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2561
2562         { }
2563 };
2564
2565 /*
2566  * Uniwill pin configuration:
2567  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2568  * line = 0x1a
2569  */
2570 static struct hda_verb alc880_uniwill_init_verbs[] = {
2571         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2572
2573         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2574         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2575         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2576         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2577         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2578         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2579         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2580         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2581         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2582         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2583         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2584         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2585         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2586         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2587
2588         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2589         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2590         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2591         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2592         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2593         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2594         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2595         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2596         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2597
2598         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2599         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2600
2601         { }
2602 };
2603
2604 /*
2605 * Uniwill P53
2606 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2607  */
2608 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2609         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2610
2611         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2612         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2613         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2614         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2615         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2616         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2617         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2618         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2619         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2620         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2621         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2622         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2623
2624         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2625         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2626         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2627         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2628         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2629         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2630
2631         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2632         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2633
2634         { }
2635 };
2636
2637 static struct hda_verb alc880_beep_init_verbs[] = {
2638         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2639         { }
2640 };
2641
2642 /* auto-toggle front mic */
2643 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2644 {
2645         unsigned int present;
2646         unsigned char bits;
2647
2648         present = snd_hda_codec_read(codec, 0x18, 0,
2649                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2650         bits = present ? HDA_AMP_MUTE : 0;
2651         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2652 }
2653
2654 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2655 {
2656         struct alc_spec *spec = codec->spec;
2657
2658         spec->autocfg.hp_pins[0] = 0x14;
2659         spec->autocfg.speaker_pins[0] = 0x15;
2660         spec->autocfg.speaker_pins[0] = 0x16;
2661         alc_automute_amp(codec);
2662         alc880_uniwill_mic_automute(codec);
2663 }
2664
2665 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2666                                        unsigned int res)
2667 {
2668         /* Looks like the unsol event is incompatible with the standard
2669          * definition.  4bit tag is placed at 28 bit!
2670          */
2671         switch (res >> 28) {
2672         case ALC880_MIC_EVENT:
2673                 alc880_uniwill_mic_automute(codec);
2674                 break;
2675         default:
2676                 alc_automute_amp_unsol_event(codec, res);
2677                 break;
2678         }
2679 }
2680
2681 static void alc880_uniwill_p53_init_hook(struct hda_codec *codec)
2682 {
2683         struct alc_spec *spec = codec->spec;
2684
2685         spec->autocfg.hp_pins[0] = 0x14;
2686         spec->autocfg.speaker_pins[0] = 0x15;
2687         alc_automute_amp(codec);
2688 }
2689
2690 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2691 {
2692         unsigned int present;
2693
2694         present = snd_hda_codec_read(codec, 0x21, 0,
2695                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2696         present &= HDA_AMP_VOLMASK;
2697         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2698                                  HDA_AMP_VOLMASK, present);
2699         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2700                                  HDA_AMP_VOLMASK, present);
2701 }
2702
2703 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2704                                            unsigned int res)
2705 {
2706         /* Looks like the unsol event is incompatible with the standard
2707          * definition.  4bit tag is placed at 28 bit!
2708          */
2709         if ((res >> 28) == ALC880_DCVOL_EVENT)
2710                 alc880_uniwill_p53_dcvol_automute(codec);
2711         else
2712                 alc_automute_amp_unsol_event(codec, res);
2713 }
2714
2715 /*
2716  * F1734 pin configuration:
2717  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2718  */
2719 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2720         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2721         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2722         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2723         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2724         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2725
2726         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2727         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2728         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2729         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2730
2731         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2732         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2733         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2734         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2735         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2736         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2737         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2738         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2739         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2740
2741         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2742         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2743
2744         { }
2745 };
2746
2747 /*
2748  * ASUS pin configuration:
2749  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2750  */
2751 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2752         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2753         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2754         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2755         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2756
2757         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2758         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2759         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2760         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2761         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2762         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2763         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2764         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2765
2766         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2767         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2768         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2769         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2770         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2771         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2772         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2773         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2774         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2775
2776         { }
2777 };
2778
2779 /* Enable GPIO mask and set output */
2780 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2781 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2782 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
2783
2784 /* Clevo m520g init */
2785 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2786         /* headphone output */
2787         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2788         /* line-out */
2789         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2790         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2791         /* Line-in */
2792         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2793         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2794         /* CD */
2795         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2796         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2797         /* Mic1 (rear panel) */
2798         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2799         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2800         /* Mic2 (front panel) */
2801         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2802         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2803         /* headphone */
2804         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2805         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2806         /* change to EAPD mode */
2807         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2808         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2809
2810         { }
2811 };
2812
2813 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2814         /* change to EAPD mode */
2815         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2816         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2817
2818         /* Headphone output */
2819         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2820         /* Front output*/
2821         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2822         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2823
2824         /* Line In pin widget for input */
2825         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2826         /* CD pin widget for input */
2827         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2828         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2829         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2830
2831         /* change to EAPD mode */
2832         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2833         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2834
2835         { }
2836 };
2837
2838 /*
2839  * LG m1 express dual
2840  *
2841  * Pin assignment:
2842  *   Rear Line-In/Out (blue): 0x14
2843  *   Build-in Mic-In: 0x15
2844  *   Speaker-out: 0x17
2845  *   HP-Out (green): 0x1b
2846  *   Mic-In/Out (red): 0x19
2847  *   SPDIF-Out: 0x1e
2848  */
2849
2850 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2851 static hda_nid_t alc880_lg_dac_nids[3] = {
2852         0x05, 0x02, 0x03
2853 };
2854
2855 /* seems analog CD is not working */
2856 static struct hda_input_mux alc880_lg_capture_source = {
2857         .num_items = 3,
2858         .items = {
2859                 { "Mic", 0x1 },
2860                 { "Line", 0x5 },
2861                 { "Internal Mic", 0x6 },
2862         },
2863 };
2864
2865 /* 2,4,6 channel modes */
2866 static struct hda_verb alc880_lg_ch2_init[] = {
2867         /* set line-in and mic-in to input */
2868         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2869         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2870         { }
2871 };
2872
2873 static struct hda_verb alc880_lg_ch4_init[] = {
2874         /* set line-in to out and mic-in to input */
2875         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2876         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2877         { }
2878 };
2879
2880 static struct hda_verb alc880_lg_ch6_init[] = {
2881         /* set line-in and mic-in to output */
2882         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2883         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2884         { }
2885 };
2886
2887 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2888         { 2, alc880_lg_ch2_init },
2889         { 4, alc880_lg_ch4_init },
2890         { 6, alc880_lg_ch6_init },
2891 };
2892
2893 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2894         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2895         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2896         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2897         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2898         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2899         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2900         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2901         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2902         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2903         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2904         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2905         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2906         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2907         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2908         {
2909                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2910                 .name = "Channel Mode",
2911                 .info = alc_ch_mode_info,
2912                 .get = alc_ch_mode_get,
2913                 .put = alc_ch_mode_put,
2914         },
2915         { } /* end */
2916 };
2917
2918 static struct hda_verb alc880_lg_init_verbs[] = {
2919         /* set capture source to mic-in */
2920         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2921         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2922         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2923         /* mute all amp mixer inputs */
2924         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2925         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2926         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2927         /* line-in to input */
2928         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2929         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2930         /* built-in mic */
2931         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2932         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2933         /* speaker-out */
2934         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2935         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2936         /* mic-in to input */
2937         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2938         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2939         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2940         /* HP-out */
2941         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2942         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2943         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2944         /* jack sense */
2945         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2946         { }
2947 };
2948
2949 /* toggle speaker-output according to the hp-jack state */
2950 static void alc880_lg_init_hook(struct hda_codec *codec)
2951 {
2952         struct alc_spec *spec = codec->spec;
2953
2954         spec->autocfg.hp_pins[0] = 0x1b;
2955         spec->autocfg.speaker_pins[0] = 0x17;
2956         alc_automute_amp(codec);
2957 }
2958
2959 /*
2960  * LG LW20
2961  *
2962  * Pin assignment:
2963  *   Speaker-out: 0x14
2964  *   Mic-In: 0x18
2965  *   Built-in Mic-In: 0x19
2966  *   Line-In: 0x1b
2967  *   HP-Out: 0x1a
2968  *   SPDIF-Out: 0x1e
2969  */
2970
2971 static struct hda_input_mux alc880_lg_lw_capture_source = {
2972         .num_items = 3,
2973         .items = {
2974                 { "Mic", 0x0 },
2975                 { "Internal Mic", 0x1 },
2976                 { "Line In", 0x2 },
2977         },
2978 };
2979
2980 #define alc880_lg_lw_modes alc880_threestack_modes
2981
2982 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2983         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2984         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2985         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2986         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2987         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2988         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2989         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2990         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2991         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2992         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2993         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2994         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2995         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2996         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2997         {
2998                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2999                 .name = "Channel Mode",
3000                 .info = alc_ch_mode_info,
3001                 .get = alc_ch_mode_get,
3002                 .put = alc_ch_mode_put,
3003         },
3004         { } /* end */
3005 };
3006
3007 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3008         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3009         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3010         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3011
3012         /* set capture source to mic-in */
3013         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3014         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3015         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3016         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3017         /* speaker-out */
3018         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3019         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3020         /* HP-out */
3021         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3022         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3023         /* mic-in to input */
3024         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3025         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3026         /* built-in mic */
3027         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3028         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3029         /* jack sense */
3030         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3031         { }
3032 };
3033
3034 /* toggle speaker-output according to the hp-jack state */
3035 static void alc880_lg_lw_init_hook(struct hda_codec *codec)
3036 {
3037         struct alc_spec *spec = codec->spec;
3038
3039         spec->autocfg.hp_pins[0] = 0x1b;
3040         spec->autocfg.speaker_pins[0] = 0x14;
3041         alc_automute_amp(codec);
3042 }
3043
3044 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3045         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3046         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3047         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3048         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3049         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3050         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3051         { } /* end */
3052 };
3053
3054 static struct hda_input_mux alc880_medion_rim_capture_source = {
3055         .num_items = 2,
3056         .items = {
3057                 { "Mic", 0x0 },
3058                 { "Internal Mic", 0x1 },
3059         },
3060 };
3061
3062 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3063         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3064
3065         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3066         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3067
3068         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3069         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3070         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3071         /* Mic2 (as headphone out) for HP output */
3072         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3073         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3074         /* Internal Speaker */
3075         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3076         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3077
3078         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3079         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3080
3081         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3082         { }
3083 };
3084
3085 /* toggle speaker-output according to the hp-jack state */
3086 static void alc880_medion_rim_automute(struct hda_codec *codec)
3087 {
3088         struct alc_spec *spec = codec->spec;
3089         alc_automute_amp(codec);
3090         /* toggle EAPD */
3091         if (spec->jack_present)
3092                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3093         else
3094                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3095 }
3096
3097 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3098                                           unsigned int res)
3099 {
3100         /* Looks like the unsol event is incompatible with the standard
3101          * definition.  4bit tag is placed at 28 bit!
3102          */
3103         if ((res >> 28) == ALC880_HP_EVENT)
3104                 alc880_medion_rim_automute(codec);
3105 }
3106
3107 static void alc880_medion_rim_init_hook(struct hda_codec *codec)
3108 {
3109         struct alc_spec *spec = codec->spec;
3110
3111         spec->autocfg.hp_pins[0] = 0x14;
3112         spec->autocfg.speaker_pins[0] = 0x1b;
3113         alc880_medion_rim_automute(codec);
3114 }
3115
3116 #ifdef CONFIG_SND_HDA_POWER_SAVE
3117 static struct hda_amp_list alc880_loopbacks[] = {
3118         { 0x0b, HDA_INPUT, 0 },
3119         { 0x0b, HDA_INPUT, 1 },
3120         { 0x0b, HDA_INPUT, 2 },
3121         { 0x0b, HDA_INPUT, 3 },
3122         { 0x0b, HDA_INPUT, 4 },
3123         { } /* end */
3124 };
3125
3126 static struct hda_amp_list alc880_lg_loopbacks[] = {
3127         { 0x0b, HDA_INPUT, 1 },
3128         { 0x0b, HDA_INPUT, 6 },
3129         { 0x0b, HDA_INPUT, 7 },
3130         { } /* end */
3131 };
3132 #endif
3133
3134 /*
3135  * Common callbacks
3136  */
3137
3138 static int alc_init(struct hda_codec *codec)
3139 {
3140         struct alc_spec *spec = codec->spec;
3141         unsigned int i;
3142
3143         alc_fix_pll(codec);
3144         alc_auto_init_amp(codec, spec->init_amp);
3145
3146         for (i = 0; i < spec->num_init_verbs; i++)
3147                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3148
3149         if (spec->init_hook)
3150                 spec->init_hook(codec);
3151
3152         return 0;
3153 }
3154
3155 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3156 {
3157         struct alc_spec *spec = codec->spec;
3158
3159         if (spec->unsol_event)
3160                 spec->unsol_event(codec, res);
3161 }
3162
3163 #ifdef CONFIG_SND_HDA_POWER_SAVE
3164 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3165 {
3166         struct alc_spec *spec = codec->spec;
3167         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3168 }
3169 #endif
3170
3171 /*
3172  * Analog playback callbacks
3173  */
3174 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3175                                     struct hda_codec *codec,
3176                                     struct snd_pcm_substream *substream)
3177 {
3178         struct alc_spec *spec = codec->spec;
3179         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3180                                              hinfo);
3181 }
3182
3183 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3184                                        struct hda_codec *codec,
3185                                        unsigned int stream_tag,
3186                                        unsigned int format,
3187                                        struct snd_pcm_substream *substream)
3188 {
3189         struct alc_spec *spec = codec->spec;
3190         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3191                                                 stream_tag, format, substream);
3192 }
3193
3194 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3195                                        struct hda_codec *codec,
3196                                        struct snd_pcm_substream *substream)
3197 {
3198         struct alc_spec *spec = codec->spec;
3199         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3200 }
3201
3202 /*
3203  * Digital out
3204  */
3205 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3206                                         struct hda_codec *codec,
3207                                         struct snd_pcm_substream *substream)
3208 {
3209         struct alc_spec *spec = codec->spec;
3210         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3211 }
3212
3213 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3214                                            struct hda_codec *codec,
3215                                            unsigned int stream_tag,
3216                                            unsigned int format,
3217                                            struct snd_pcm_substream *substream)
3218 {
3219         struct alc_spec *spec = codec->spec;
3220         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3221                                              stream_tag, format, substream);
3222 }
3223
3224 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3225                                            struct hda_codec *codec,
3226                                            struct snd_pcm_substream *substream)
3227 {
3228         struct alc_spec *spec = codec->spec;
3229         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3230 }
3231
3232 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3233                                          struct hda_codec *codec,
3234                                          struct snd_pcm_substream *substream)
3235 {
3236         struct alc_spec *spec = codec->spec;
3237         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3238 }
3239
3240 /*
3241  * Analog capture
3242  */
3243 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3244                                       struct hda_codec *codec,
3245                                       unsigned int stream_tag,
3246                                       unsigned int format,
3247                                       struct snd_pcm_substream *substream)
3248 {
3249         struct alc_spec *spec = codec->spec;
3250
3251         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3252                                    stream_tag, 0, format);
3253         return 0;
3254 }
3255
3256 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3257                                       struct hda_codec *codec,
3258                                       struct snd_pcm_substream *substream)
3259 {
3260         struct alc_spec *spec = codec->spec;
3261
3262         snd_hda_codec_cleanup_stream(codec,
3263                                      spec->adc_nids[substream->number + 1]);
3264         return 0;
3265 }
3266
3267
3268 /*
3269  */
3270 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3271         .substreams = 1,
3272         .channels_min = 2,
3273         .channels_max = 8,
3274         /* NID is set in alc_build_pcms */
3275         .ops = {
3276                 .open = alc880_playback_pcm_open,
3277                 .prepare = alc880_playback_pcm_prepare,
3278                 .cleanup = alc880_playback_pcm_cleanup
3279         },
3280 };
3281
3282 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3283         .substreams = 1,
3284         .channels_min = 2,
3285         .channels_max = 2,
3286         /* NID is set in alc_build_pcms */
3287 };
3288
3289 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3290         .substreams = 1,
3291         .channels_min = 2,
3292         .channels_max = 2,
3293         /* NID is set in alc_build_pcms */
3294 };
3295
3296 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3297         .substreams = 2, /* can be overridden */
3298         .channels_min = 2,
3299         .channels_max = 2,
3300         /* NID is set in alc_build_pcms */
3301         .ops = {
3302                 .prepare = alc880_alt_capture_pcm_prepare,
3303                 .cleanup = alc880_alt_capture_pcm_cleanup
3304         },
3305 };
3306
3307 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3308         .substreams = 1,
3309         .channels_min = 2,
3310         .channels_max = 2,
3311         /* NID is set in alc_build_pcms */
3312         .ops = {
3313                 .open = alc880_dig_playback_pcm_open,
3314                 .close = alc880_dig_playback_pcm_close,
3315                 .prepare = alc880_dig_playback_pcm_prepare,
3316                 .cleanup = alc880_dig_playback_pcm_cleanup
3317         },
3318 };
3319
3320 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3321         .substreams = 1,
3322         .channels_min = 2,
3323         .channels_max = 2,
3324         /* NID is set in alc_build_pcms */
3325 };
3326
3327 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3328 static struct hda_pcm_stream alc_pcm_null_stream = {
3329         .substreams = 0,
3330         .channels_min = 0,
3331         .channels_max = 0,
3332 };
3333
3334 static int alc_build_pcms(struct hda_codec *codec)
3335 {
3336         struct alc_spec *spec = codec->spec;
3337         struct hda_pcm *info = spec->pcm_rec;
3338         int i;
3339
3340         codec->num_pcms = 1;
3341         codec->pcm_info = info;
3342
3343         if (spec->no_analog)
3344                 goto skip_analog;
3345
3346         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3347                  "%s Analog", codec->chip_name);
3348         info->name = spec->stream_name_analog;
3349
3350         if (spec->stream_analog_playback) {
3351                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3352                         return -EINVAL;
3353                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3354                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3355         }
3356         if (spec->stream_analog_capture) {
3357                 if (snd_BUG_ON(!spec->adc_nids))
3358                         return -EINVAL;
3359                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3360                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3361         }
3362
3363         if (spec->channel_mode) {
3364                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3365                 for (i = 0; i < spec->num_channel_mode; i++) {
3366                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3367                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3368                         }
3369                 }
3370         }
3371
3372  skip_analog:
3373         /* SPDIF for stream index #1 */
3374         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3375                 snprintf(spec->stream_name_digital,
3376                          sizeof(spec->stream_name_digital),
3377                          "%s Digital", codec->chip_name);
3378                 codec->num_pcms = 2;
3379                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3380                 info = spec->pcm_rec + 1;
3381                 info->name = spec->stream_name_digital;
3382                 if (spec->dig_out_type)
3383                         info->pcm_type = spec->dig_out_type;
3384                 else
3385                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3386                 if (spec->multiout.dig_out_nid &&
3387                     spec->stream_digital_playback) {
3388                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3389                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3390                 }
3391                 if (spec->dig_in_nid &&
3392                     spec->stream_digital_capture) {
3393                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3394                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3395                 }
3396                 /* FIXME: do we need this for all Realtek codec models? */
3397                 codec->spdif_status_reset = 1;
3398         }
3399
3400         if (spec->no_analog)
3401                 return 0;
3402
3403         /* If the use of more than one ADC is requested for the current
3404          * model, configure a second analog capture-only PCM.
3405          */
3406         /* Additional Analaog capture for index #2 */
3407         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3408             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3409                 codec->num_pcms = 3;
3410                 info = spec->pcm_rec + 2;
3411                 info->name = spec->stream_name_analog;
3412                 if (spec->alt_dac_nid) {
3413                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3414                                 *spec->stream_analog_alt_playback;
3415                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3416                                 spec->alt_dac_nid;
3417                 } else {
3418                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3419                                 alc_pcm_null_stream;
3420                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3421                 }
3422                 if (spec->num_adc_nids > 1) {
3423                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3424                                 *spec->stream_analog_alt_capture;
3425                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3426                                 spec->adc_nids[1];
3427                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3428                                 spec->num_adc_nids - 1;
3429                 } else {
3430                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3431                                 alc_pcm_null_stream;
3432                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3433                 }
3434         }
3435
3436         return 0;
3437 }
3438
3439 static void alc_free_kctls(struct hda_codec *codec)
3440 {
3441         struct alc_spec *spec = codec->spec;
3442
3443         if (spec->kctls.list) {
3444                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3445                 int i;
3446                 for (i = 0; i < spec->kctls.used; i++)
3447                         kfree(kctl[i].name);
3448         }
3449         snd_array_free(&spec->kctls);
3450 }
3451
3452 static void alc_free(struct hda_codec *codec)
3453 {
3454         struct alc_spec *spec = codec->spec;
3455
3456         if (!spec)
3457                 return;
3458
3459         alc_free_kctls(codec);
3460         kfree(spec);
3461         snd_hda_detach_beep_device(codec);
3462 }
3463
3464 #ifdef SND_HDA_NEEDS_RESUME
3465 static int alc_resume(struct hda_codec *codec)
3466 {
3467         codec->patch_ops.init(codec);
3468         snd_hda_codec_resume_amp(codec);
3469         snd_hda_codec_resume_cache(codec);
3470         return 0;
3471 }
3472 #endif
3473
3474 /*
3475  */
3476 static struct hda_codec_ops alc_patch_ops = {
3477         .build_controls = alc_build_controls,
3478         .build_pcms = alc_build_pcms,
3479         .init = alc_init,
3480         .free = alc_free,
3481         .unsol_event = alc_unsol_event,
3482 #ifdef SND_HDA_NEEDS_RESUME
3483         .resume = alc_resume,
3484 #endif
3485 #ifdef CONFIG_SND_HDA_POWER_SAVE
3486         .check_power_status = alc_check_power_status,
3487 #endif
3488 };
3489
3490
3491 /*
3492  * Test configuration for debugging
3493  *
3494  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3495  * enum controls.
3496  */
3497 #ifdef CONFIG_SND_DEBUG
3498 static hda_nid_t alc880_test_dac_nids[4] = {
3499         0x02, 0x03, 0x04, 0x05
3500 };
3501
3502 static struct hda_input_mux alc880_test_capture_source = {
3503         .num_items = 7,
3504         .items = {
3505                 { "In-1", 0x0 },
3506                 { "In-2", 0x1 },
3507                 { "In-3", 0x2 },
3508                 { "In-4", 0x3 },
3509                 { "CD", 0x4 },
3510                 { "Front", 0x5 },
3511                 { "Surround", 0x6 },
3512         },
3513 };
3514
3515 static struct hda_channel_mode alc880_test_modes[4] = {
3516         { 2, NULL },
3517         { 4, NULL },
3518         { 6, NULL },
3519         { 8, NULL },
3520 };
3521
3522 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3523                                  struct snd_ctl_elem_info *uinfo)
3524 {
3525         static char *texts[] = {
3526                 "N/A", "Line Out", "HP Out",
3527                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3528         };
3529         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3530         uinfo->count = 1;
3531         uinfo->value.enumerated.items = 8;
3532         if (uinfo->value.enumerated.item >= 8)
3533                 uinfo->value.enumerated.item = 7;
3534         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3535         return 0;
3536 }
3537
3538 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3539                                 struct snd_ctl_elem_value *ucontrol)
3540 {
3541         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3542         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3543         unsigned int pin_ctl, item = 0;
3544
3545         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3546                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3547         if (pin_ctl & AC_PINCTL_OUT_EN) {
3548                 if (pin_ctl & AC_PINCTL_HP_EN)
3549                         item = 2;
3550                 else
3551                         item = 1;
3552         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3553                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3554                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3555                 case AC_PINCTL_VREF_50:  item = 4; break;
3556                 case AC_PINCTL_VREF_GRD: item = 5; break;
3557                 case AC_PINCTL_VREF_80:  item = 6; break;
3558                 case AC_PINCTL_VREF_100: item = 7; break;
3559                 }
3560         }
3561         ucontrol->value.enumerated.item[0] = item;
3562         return 0;
3563 }
3564
3565 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3566                                 struct snd_ctl_elem_value *ucontrol)
3567 {
3568         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3569         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3570         static unsigned int ctls[] = {
3571                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3572                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3573                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3574                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3575                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3576                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3577         };
3578         unsigned int old_ctl, new_ctl;
3579
3580         old_ctl = snd_hda_codec_read(codec, nid, 0,
3581                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3582         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3583         if (old_ctl != new_ctl) {
3584                 int val;
3585                 snd_hda_codec_write_cache(codec, nid, 0,
3586                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3587                                           new_ctl);
3588                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3589                         HDA_AMP_MUTE : 0;
3590                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3591                                          HDA_AMP_MUTE, val);
3592                 return 1;
3593         }
3594         return 0;
3595 }
3596
3597 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3598                                  struct snd_ctl_elem_info *uinfo)
3599 {
3600         static char *texts[] = {
3601                 "Front", "Surround", "CLFE", "Side"
3602         };
3603         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3604         uinfo->count = 1;
3605         uinfo->value.enumerated.items = 4;
3606         if (uinfo->value.enumerated.item >= 4)
3607                 uinfo->value.enumerated.item = 3;
3608         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3609         return 0;
3610 }
3611
3612 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3613                                 struct snd_ctl_elem_value *ucontrol)
3614 {
3615         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3616         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3617         unsigned int sel;
3618
3619         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3620         ucontrol->value.enumerated.item[0] = sel & 3;
3621         return 0;
3622 }
3623
3624 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3625                                 struct snd_ctl_elem_value *ucontrol)
3626 {
3627         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3628         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3629         unsigned int sel;
3630
3631         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3632         if (ucontrol->value.enumerated.item[0] != sel) {
3633                 sel = ucontrol->value.enumerated.item[0] & 3;
3634                 snd_hda_codec_write_cache(codec, nid, 0,
3635                                           AC_VERB_SET_CONNECT_SEL, sel);
3636                 return 1;
3637         }
3638         return 0;
3639 }
3640
3641 #define PIN_CTL_TEST(xname,nid) {                       \
3642                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3643                         .name = xname,                 \
3644                         .info = alc_test_pin_ctl_info, \
3645                         .get = alc_test_pin_ctl_get,   \
3646                         .put = alc_test_pin_ctl_put,   \
3647                         .private_value = nid           \
3648                         }
3649
3650 #define PIN_SRC_TEST(xname,nid) {                       \
3651                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3652                         .name = xname,                 \
3653                         .info = alc_test_pin_src_info, \
3654                         .get = alc_test_pin_src_get,   \
3655                         .put = alc_test_pin_src_put,   \
3656                         .private_value = nid           \
3657                         }
3658
3659 static struct snd_kcontrol_new alc880_test_mixer[] = {
3660         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3661         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3662         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3663         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3664         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3665         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3666         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3667         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3668         PIN_CTL_TEST("Front Pin Mode", 0x14),
3669         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3670         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3671         PIN_CTL_TEST("Side Pin Mode", 0x17),
3672         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3673         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3674         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3675         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3676         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3677         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3678         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3679         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3680         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3681         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3682         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3683         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3684         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3685         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3686         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3687         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3688         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3689         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3690         {
3691                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3692                 .name = "Channel Mode",
3693                 .info = alc_ch_mode_info,
3694                 .get = alc_ch_mode_get,
3695                 .put = alc_ch_mode_put,
3696         },
3697         { } /* end */
3698 };
3699
3700 static struct hda_verb alc880_test_init_verbs[] = {
3701         /* Unmute inputs of 0x0c - 0x0f */
3702         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3703         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3704         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3705         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3706         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3707         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3708         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3709         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3710         /* Vol output for 0x0c-0x0f */
3711         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3712         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3713         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3714         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3715         /* Set output pins 0x14-0x17 */
3716         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3717         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3718         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3719         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3720         /* Unmute output pins 0x14-0x17 */
3721         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3722         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3723         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3724         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3725         /* Set input pins 0x18-0x1c */
3726         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3727         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3728         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3729         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3730         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3731         /* Mute input pins 0x18-0x1b */
3732         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3733         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3734         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3735         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3736         /* ADC set up */
3737         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3738         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3739         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3740         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3741         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3742         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3743         /* Analog input/passthru */
3744         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3745         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3746         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3747         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3748         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3749         { }
3750 };
3751 #endif
3752
3753 /*
3754  */
3755
3756 static const char *alc880_models[ALC880_MODEL_LAST] = {
3757         [ALC880_3ST]            = "3stack",
3758         [ALC880_TCL_S700]       = "tcl",
3759         [ALC880_3ST_DIG]        = "3stack-digout",
3760         [ALC880_CLEVO]          = "clevo",
3761         [ALC880_5ST]            = "5stack",
3762         [ALC880_5ST_DIG]        = "5stack-digout",
3763         [ALC880_W810]           = "w810",
3764         [ALC880_Z71V]           = "z71v",
3765         [ALC880_6ST]            = "6stack",
3766         [ALC880_6ST_DIG]        = "6stack-digout",
3767         [ALC880_ASUS]           = "asus",
3768         [ALC880_ASUS_W1V]       = "asus-w1v",
3769         [ALC880_ASUS_DIG]       = "asus-dig",
3770         [ALC880_ASUS_DIG2]      = "asus-dig2",
3771         [ALC880_UNIWILL_DIG]    = "uniwill",
3772         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3773         [ALC880_FUJITSU]        = "fujitsu",
3774         [ALC880_F1734]          = "F1734",
3775         [ALC880_LG]             = "lg",
3776         [ALC880_LG_LW]          = "lg-lw",
3777         [ALC880_MEDION_RIM]     = "medion",
3778 #ifdef CONFIG_SND_DEBUG
3779         [ALC880_TEST]           = "test",
3780 #endif
3781         [ALC880_AUTO]           = "auto",
3782 };
3783
3784 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3785         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3786         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3787         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3788         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3789         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3790         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3791         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3792         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3793         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3794         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3795         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3796         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3797         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3798         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3799         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3800         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3801         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3802         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3803         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3804         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3805         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3806         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3807         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3808         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3809         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3810         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
3811         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3812         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3813         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3814         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3815         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3816         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3817         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3818         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3819         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3820         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3821         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3822         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3823         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3824         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3825         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3826         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3827         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3828         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3829         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3830         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3831         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3832         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3833         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3834         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3835         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3836         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3837         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3838         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3839         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3840         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3841         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3842         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3843         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3844         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3845         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3846         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3847         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3848         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3849         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3850         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3851         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3852         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3853         /* default Intel */
3854         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
3855         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3856         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3857         {}
3858 };
3859
3860 /*
3861  * ALC880 codec presets
3862  */
3863 static struct alc_config_preset alc880_presets[] = {
3864         [ALC880_3ST] = {
3865                 .mixers = { alc880_three_stack_mixer },
3866                 .init_verbs = { alc880_volume_init_verbs,
3867                                 alc880_pin_3stack_init_verbs },
3868                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3869                 .dac_nids = alc880_dac_nids,
3870                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3871                 .channel_mode = alc880_threestack_modes,
3872                 .need_dac_fix = 1,
3873                 .input_mux = &alc880_capture_source,
3874         },
3875         [ALC880_3ST_DIG] = {
3876                 .mixers = { alc880_three_stack_mixer },
3877                 .init_verbs = { alc880_volume_init_verbs,
3878                                 alc880_pin_3stack_init_verbs },
3879                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3880                 .dac_nids = alc880_dac_nids,
3881                 .dig_out_nid = ALC880_DIGOUT_NID,
3882                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3883                 .channel_mode = alc880_threestack_modes,
3884                 .need_dac_fix = 1,
3885                 .input_mux = &alc880_capture_source,
3886         },
3887         [ALC880_TCL_S700] = {
3888                 .mixers = { alc880_tcl_s700_mixer },
3889                 .init_verbs = { alc880_volume_init_verbs,
3890                                 alc880_pin_tcl_S700_init_verbs,
3891                                 alc880_gpio2_init_verbs },
3892                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3893                 .dac_nids = alc880_dac_nids,
3894                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
3895                 .num_adc_nids = 1, /* single ADC */
3896                 .hp_nid = 0x03,
3897                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3898                 .channel_mode = alc880_2_jack_modes,
3899                 .input_mux = &alc880_capture_source,
3900         },
3901         [ALC880_5ST] = {
3902                 .mixers = { alc880_three_stack_mixer,
3903                             alc880_five_stack_mixer},
3904                 .init_verbs = { alc880_volume_init_verbs,
3905                                 alc880_pin_5stack_init_verbs },
3906                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3907                 .dac_nids = alc880_dac_nids,
3908                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3909                 .channel_mode = alc880_fivestack_modes,
3910                 .input_mux = &alc880_capture_source,
3911         },
3912         [ALC880_5ST_DIG] = {
3913                 .mixers = { alc880_three_stack_mixer,
3914                             alc880_five_stack_mixer },
3915                 .init_verbs = { alc880_volume_init_verbs,
3916                                 alc880_pin_5stack_init_verbs },
3917                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3918                 .dac_nids = alc880_dac_nids,
3919                 .dig_out_nid = ALC880_DIGOUT_NID,
3920                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3921                 .channel_mode = alc880_fivestack_modes,
3922                 .input_mux = &alc880_capture_source,
3923         },
3924         [ALC880_6ST] = {
3925                 .mixers = { alc880_six_stack_mixer },
3926                 .init_verbs = { alc880_volume_init_verbs,
3927                                 alc880_pin_6stack_init_verbs },
3928                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3929                 .dac_nids = alc880_6st_dac_nids,
3930                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3931                 .channel_mode = alc880_sixstack_modes,
3932                 .input_mux = &alc880_6stack_capture_source,
3933         },
3934         [ALC880_6ST_DIG] = {
3935                 .mixers = { alc880_six_stack_mixer },
3936                 .init_verbs = { alc880_volume_init_verbs,
3937                                 alc880_pin_6stack_init_verbs },
3938                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3939                 .dac_nids = alc880_6st_dac_nids,
3940                 .dig_out_nid = ALC880_DIGOUT_NID,
3941                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3942                 .channel_mode = alc880_sixstack_modes,
3943                 .input_mux = &alc880_6stack_capture_source,
3944         },
3945         [ALC880_W810] = {
3946                 .mixers = { alc880_w810_base_mixer },
3947                 .init_verbs = { alc880_volume_init_verbs,
3948                                 alc880_pin_w810_init_verbs,
3949                                 alc880_gpio2_init_verbs },
3950                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3951                 .dac_nids = alc880_w810_dac_nids,
3952                 .dig_out_nid = ALC880_DIGOUT_NID,
3953                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3954                 .channel_mode = alc880_w810_modes,
3955                 .input_mux = &alc880_capture_source,
3956         },
3957         [ALC880_Z71V] = {
3958                 .mixers = { alc880_z71v_mixer },
3959                 .init_verbs = { alc880_volume_init_verbs,
3960                                 alc880_pin_z71v_init_verbs },
3961                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3962                 .dac_nids = alc880_z71v_dac_nids,
3963                 .dig_out_nid = ALC880_DIGOUT_NID,
3964                 .hp_nid = 0x03,
3965                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3966                 .channel_mode = alc880_2_jack_modes,
3967                 .input_mux = &alc880_capture_source,
3968         },
3969         [ALC880_F1734] = {
3970                 .mixers = { alc880_f1734_mixer },
3971                 .init_verbs = { alc880_volume_init_verbs,
3972                                 alc880_pin_f1734_init_verbs },
3973                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3974                 .dac_nids = alc880_f1734_dac_nids,
3975                 .hp_nid = 0x02,
3976                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3977                 .channel_mode = alc880_2_jack_modes,
3978                 .input_mux = &alc880_f1734_capture_source,
3979                 .unsol_event = alc880_uniwill_p53_unsol_event,
3980                 .init_hook = alc880_uniwill_p53_init_hook,
3981         },
3982         [ALC880_ASUS] = {
3983                 .mixers = { alc880_asus_mixer },
3984                 .init_verbs = { alc880_volume_init_verbs,
3985                                 alc880_pin_asus_init_verbs,
3986                                 alc880_gpio1_init_verbs },
3987                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3988                 .dac_nids = alc880_asus_dac_nids,
3989                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3990                 .channel_mode = alc880_asus_modes,
3991                 .need_dac_fix = 1,
3992                 .input_mux = &alc880_capture_source,
3993         },
3994         [ALC880_ASUS_DIG] = {
3995                 .mixers = { alc880_asus_mixer },
3996                 .init_verbs = { alc880_volume_init_verbs,
3997                                 alc880_pin_asus_init_verbs,
3998                                 alc880_gpio1_init_verbs },
3999                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4000                 .dac_nids = alc880_asus_dac_nids,
4001                 .dig_out_nid = ALC880_DIGOUT_NID,
4002                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4003                 .channel_mode = alc880_asus_modes,
4004                 .need_dac_fix = 1,
4005                 .input_mux = &alc880_capture_source,
4006         },
4007         [ALC880_ASUS_DIG2] = {
4008                 .mixers = { alc880_asus_mixer },
4009                 .init_verbs = { alc880_volume_init_verbs,
4010                                 alc880_pin_asus_init_verbs,
4011                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4012                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4013                 .dac_nids = alc880_asus_dac_nids,
4014                 .dig_out_nid = ALC880_DIGOUT_NID,
4015                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4016                 .channel_mode = alc880_asus_modes,
4017                 .need_dac_fix = 1,
4018                 .input_mux = &alc880_capture_source,
4019         },
4020         [ALC880_ASUS_W1V] = {
4021                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4022                 .init_verbs = { alc880_volume_init_verbs,
4023                                 alc880_pin_asus_init_verbs,
4024                                 alc880_gpio1_init_verbs },
4025                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4026                 .dac_nids = alc880_asus_dac_nids,
4027                 .dig_out_nid = ALC880_DIGOUT_NID,
4028                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4029                 .channel_mode = alc880_asus_modes,
4030                 .need_dac_fix = 1,
4031                 .input_mux = &alc880_capture_source,
4032         },
4033         [ALC880_UNIWILL_DIG] = {
4034                 .mixers = { alc880_asus_mixer },
4035                 .init_verbs = { alc880_volume_init_verbs,
4036                                 alc880_pin_asus_init_verbs },
4037                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4038                 .dac_nids = alc880_asus_dac_nids,
4039                 .dig_out_nid = ALC880_DIGOUT_NID,
4040                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4041                 .channel_mode = alc880_asus_modes,
4042                 .need_dac_fix = 1,
4043                 .input_mux = &alc880_capture_source,
4044         },
4045         [ALC880_UNIWILL] = {
4046                 .mixers = { alc880_uniwill_mixer },
4047                 .init_verbs = { alc880_volume_init_verbs,
4048                                 alc880_uniwill_init_verbs },
4049                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4050                 .dac_nids = alc880_asus_dac_nids,
4051                 .dig_out_nid = ALC880_DIGOUT_NID,
4052                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4053                 .channel_mode = alc880_threestack_modes,
4054                 .need_dac_fix = 1,
4055                 .input_mux = &alc880_capture_source,
4056                 .unsol_event = alc880_uniwill_unsol_event,
4057                 .init_hook = alc880_uniwill_init_hook,
4058         },
4059         [ALC880_UNIWILL_P53] = {
4060                 .mixers = { alc880_uniwill_p53_mixer },
4061                 .init_verbs = { alc880_volume_init_verbs,
4062                                 alc880_uniwill_p53_init_verbs },
4063                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4064                 .dac_nids = alc880_asus_dac_nids,
4065                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4066                 .channel_mode = alc880_threestack_modes,
4067                 .input_mux = &alc880_capture_source,
4068                 .unsol_event = alc880_uniwill_p53_unsol_event,
4069                 .init_hook = alc880_uniwill_p53_init_hook,
4070         },
4071         [ALC880_FUJITSU] = {
4072                 .mixers = { alc880_fujitsu_mixer },
4073                 .init_verbs = { alc880_volume_init_verbs,
4074                                 alc880_uniwill_p53_init_verbs,
4075                                 alc880_beep_init_verbs },
4076                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4077                 .dac_nids = alc880_dac_nids,
4078                 .dig_out_nid = ALC880_DIGOUT_NID,
4079                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4080                 .channel_mode = alc880_2_jack_modes,
4081                 .input_mux = &alc880_capture_source,
4082                 .unsol_event = alc880_uniwill_p53_unsol_event,
4083                 .init_hook = alc880_uniwill_p53_init_hook,
4084         },
4085         [ALC880_CLEVO] = {
4086                 .mixers = { alc880_three_stack_mixer },
4087                 .init_verbs = { alc880_volume_init_verbs,
4088                                 alc880_pin_clevo_init_verbs },
4089                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4090                 .dac_nids = alc880_dac_nids,
4091                 .hp_nid = 0x03,
4092                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4093                 .channel_mode = alc880_threestack_modes,
4094                 .need_dac_fix = 1,
4095                 .input_mux = &alc880_capture_source,
4096         },
4097         [ALC880_LG] = {
4098                 .mixers = { alc880_lg_mixer },
4099                 .init_verbs = { alc880_volume_init_verbs,
4100                                 alc880_lg_init_verbs },
4101                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4102                 .dac_nids = alc880_lg_dac_nids,
4103                 .dig_out_nid = ALC880_DIGOUT_NID,
4104                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4105                 .channel_mode = alc880_lg_ch_modes,
4106                 .need_dac_fix = 1,
4107                 .input_mux = &alc880_lg_capture_source,
4108                 .unsol_event = alc_automute_amp_unsol_event,
4109                 .init_hook = alc880_lg_init_hook,
4110 #ifdef CONFIG_SND_HDA_POWER_SAVE
4111                 .loopbacks = alc880_lg_loopbacks,
4112 #endif
4113         },
4114         [ALC880_LG_LW] = {
4115                 .mixers = { alc880_lg_lw_mixer },
4116                 .init_verbs = { alc880_volume_init_verbs,
4117                                 alc880_lg_lw_init_verbs },
4118                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4119                 .dac_nids = alc880_dac_nids,
4120                 .dig_out_nid = ALC880_DIGOUT_NID,
4121                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4122                 .channel_mode = alc880_lg_lw_modes,
4123                 .input_mux = &alc880_lg_lw_capture_source,
4124                 .unsol_event = alc_automute_amp_unsol_event,
4125                 .init_hook = alc880_lg_lw_init_hook,
4126         },
4127         [ALC880_MEDION_RIM] = {
4128                 .mixers = { alc880_medion_rim_mixer },
4129                 .init_verbs = { alc880_volume_init_verbs,
4130                                 alc880_medion_rim_init_verbs,
4131                                 alc_gpio2_init_verbs },
4132                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4133                 .dac_nids = alc880_dac_nids,
4134                 .dig_out_nid = ALC880_DIGOUT_NID,
4135                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4136                 .channel_mode = alc880_2_jack_modes,
4137                 .input_mux = &alc880_medion_rim_capture_source,
4138                 .unsol_event = alc880_medion_rim_unsol_event,
4139                 .init_hook = alc880_medion_rim_init_hook,
4140         },
4141 #ifdef CONFIG_SND_DEBUG
4142         [ALC880_TEST] = {
4143                 .mixers = { alc880_test_mixer },
4144                 .init_verbs = { alc880_test_init_verbs },
4145                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4146                 .dac_nids = alc880_test_dac_nids,
4147                 .dig_out_nid = ALC880_DIGOUT_NID,
4148                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4149                 .channel_mode = alc880_test_modes,
4150                 .input_mux = &alc880_test_capture_source,
4151         },
4152 #endif
4153 };
4154
4155 /*
4156  * Automatic parse of I/O pins from the BIOS configuration
4157  */
4158
4159 enum {
4160         ALC_CTL_WIDGET_VOL,
4161         ALC_CTL_WIDGET_MUTE,
4162         ALC_CTL_BIND_MUTE,
4163 };
4164 static struct snd_kcontrol_new alc880_control_templates[] = {
4165         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4166         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4167         HDA_BIND_MUTE(NULL, 0, 0, 0),
4168 };
4169
4170 /* add dynamic controls */
4171 static int add_control(struct alc_spec *spec, int type, const char *name,
4172                        unsigned long val)
4173 {
4174         struct snd_kcontrol_new *knew;
4175
4176         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4177         knew = snd_array_new(&spec->kctls);
4178         if (!knew)
4179                 return -ENOMEM;
4180         *knew = alc880_control_templates[type];
4181         knew->name = kstrdup(name, GFP_KERNEL);
4182         if (!knew->name)
4183                 return -ENOMEM;
4184         knew->private_value = val;
4185         return 0;
4186 }
4187
4188 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4189 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4190 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4191 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4192 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
4193 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
4194 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4195 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4196 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4197 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4198 #define ALC880_PIN_CD_NID               0x1c
4199
4200 /* fill in the dac_nids table from the parsed pin configuration */
4201 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4202                                      const struct auto_pin_cfg *cfg)
4203 {
4204         hda_nid_t nid;
4205         int assigned[4];
4206         int i, j;
4207
4208         memset(assigned, 0, sizeof(assigned));
4209         spec->multiout.dac_nids = spec->private_dac_nids;
4210
4211         /* check the pins hardwired to audio widget */
4212         for (i = 0; i < cfg->line_outs; i++) {
4213                 nid = cfg->line_out_pins[i];
4214                 if (alc880_is_fixed_pin(nid)) {
4215                         int idx = alc880_fixed_pin_idx(nid);
4216                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4217                         assigned[idx] = 1;
4218                 }
4219         }
4220         /* left pins can be connect to any audio widget */
4221         for (i = 0; i < cfg->line_outs; i++) {
4222                 nid = cfg->line_out_pins[i];
4223                 if (alc880_is_fixed_pin(nid))
4224                         continue;
4225                 /* search for an empty channel */
4226                 for (j = 0; j < cfg->line_outs; j++) {
4227                         if (!assigned[j]) {
4228                                 spec->multiout.dac_nids[i] =
4229                                         alc880_idx_to_dac(j);
4230                                 assigned[j] = 1;
4231                                 break;
4232                         }
4233                 }
4234         }
4235         spec->multiout.num_dacs = cfg->line_outs;
4236         return 0;
4237 }
4238
4239 /* add playback controls from the parsed DAC table */
4240 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4241                                              const struct auto_pin_cfg *cfg)
4242 {
4243         char name[32];
4244         static const char *chname[4] = {
4245                 "Front", "Surround", NULL /*CLFE*/, "Side"
4246         };
4247         hda_nid_t nid;
4248         int i, err;
4249
4250         for (i = 0; i < cfg->line_outs; i++) {
4251                 if (!spec->multiout.dac_nids[i])
4252                         continue;
4253                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4254                 if (i == 2) {
4255                         /* Center/LFE */
4256                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4257                                           "Center Playback Volume",
4258                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4259                                                               HDA_OUTPUT));
4260                         if (err < 0)
4261                                 return err;
4262                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4263                                           "LFE Playback Volume",
4264                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4265                                                               HDA_OUTPUT));
4266                         if (err < 0)
4267                                 return err;
4268                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4269                                           "Center Playback Switch",
4270                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4271                                                               HDA_INPUT));
4272                         if (err < 0)
4273                                 return err;
4274                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4275                                           "LFE Playback Switch",
4276                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4277                                                               HDA_INPUT));
4278                         if (err < 0)
4279                                 return err;
4280                 } else {
4281                         sprintf(name, "%s Playback Volume", chname[i]);
4282                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4283                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4284                                                               HDA_OUTPUT));
4285                         if (err < 0)
4286                                 return err;
4287                         sprintf(name, "%s Playback Switch", chname[i]);
4288                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4289                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4290                                                               HDA_INPUT));
4291                         if (err < 0)
4292                                 return err;
4293                 }
4294         }
4295         return 0;
4296 }
4297
4298 /* add playback controls for speaker and HP outputs */
4299 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4300                                         const char *pfx)
4301 {
4302         hda_nid_t nid;
4303         int err;
4304         char name[32];
4305
4306         if (!pin)
4307                 return 0;
4308
4309         if (alc880_is_fixed_pin(pin)) {
4310                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4311                 /* specify the DAC as the extra output */
4312                 if (!spec->multiout.hp_nid)
4313                         spec->multiout.hp_nid = nid;
4314                 else
4315                         spec->multiout.extra_out_nid[0] = nid;
4316                 /* control HP volume/switch on the output mixer amp */
4317                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4318                 sprintf(name, "%s Playback Volume", pfx);
4319                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4320                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4321                 if (err < 0)
4322                         return err;
4323                 sprintf(name, "%s Playback Switch", pfx);
4324                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4325                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4326                 if (err < 0)
4327                         return err;
4328         } else if (alc880_is_multi_pin(pin)) {
4329                 /* set manual connection */
4330                 /* we have only a switch on HP-out PIN */
4331                 sprintf(name, "%s Playback Switch", pfx);
4332                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4333                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4334                 if (err < 0)
4335                         return err;
4336         }
4337         return 0;
4338 }
4339
4340 /* create input playback/capture controls for the given pin */
4341 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4342                             const char *ctlname,
4343                             int idx, hda_nid_t mix_nid)
4344 {
4345         char name[32];
4346         int err;
4347
4348         sprintf(name, "%s Playback Volume", ctlname);
4349         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4350                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4351         if (err < 0)
4352                 return err;
4353         sprintf(name, "%s Playback Switch", ctlname);
4354         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4355                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4356         if (err < 0)
4357                 return err;
4358         return 0;
4359 }
4360
4361 /* create playback/capture controls for input pins */
4362 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
4363                                                 const struct auto_pin_cfg *cfg)
4364 {
4365         struct hda_input_mux *imux = &spec->private_imux[0];
4366         int i, err, idx;
4367
4368         for (i = 0; i < AUTO_PIN_LAST; i++) {
4369                 if (alc880_is_input_pin(cfg->input_pins[i])) {
4370                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
4371                         err = new_analog_input(spec, cfg->input_pins[i],
4372                                                auto_pin_cfg_labels[i],
4373                                                idx, 0x0b);
4374                         if (err < 0)
4375                                 return err;
4376                         imux->items[imux->num_items].label =
4377                                 auto_pin_cfg_labels[i];
4378                         imux->items[imux->num_items].index =
4379                                 alc880_input_pin_idx(cfg->input_pins[i]);
4380                         imux->num_items++;
4381                 }
4382         }
4383         return 0;
4384 }
4385
4386 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4387                                unsigned int pin_type)
4388 {
4389         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4390                             pin_type);
4391         /* unmute pin */
4392         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4393                             AMP_OUT_UNMUTE);
4394 }
4395
4396 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4397                                               hda_nid_t nid, int pin_type,
4398                                               int dac_idx)
4399 {
4400         alc_set_pin_output(codec, nid, pin_type);
4401         /* need the manual connection? */
4402         if (alc880_is_multi_pin(nid)) {
4403                 struct alc_spec *spec = codec->spec;
4404                 int idx = alc880_multi_pin_idx(nid);
4405                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4406                                     AC_VERB_SET_CONNECT_SEL,
4407                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4408         }
4409 }
4410
4411 static int get_pin_type(int line_out_type)
4412 {
4413         if (line_out_type == AUTO_PIN_HP_OUT)
4414                 return PIN_HP;
4415         else
4416                 return PIN_OUT;
4417 }
4418
4419 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4420 {
4421         struct alc_spec *spec = codec->spec;
4422         int i;
4423
4424         for (i = 0; i < spec->autocfg.line_outs; i++) {
4425                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4426                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4427                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4428         }
4429 }
4430
4431 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4432 {
4433         struct alc_spec *spec = codec->spec;
4434         hda_nid_t pin;
4435
4436         pin = spec->autocfg.speaker_pins[0];
4437         if (pin) /* connect to front */
4438                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4439         pin = spec->autocfg.hp_pins[0];
4440         if (pin) /* connect to front */
4441                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4442 }
4443
4444 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4445 {
4446         struct alc_spec *spec = codec->spec;
4447         int i;
4448
4449         for (i = 0; i < AUTO_PIN_LAST; i++) {
4450                 hda_nid_t nid = spec->autocfg.input_pins[i];
4451                 if (alc880_is_input_pin(nid)) {
4452                         alc_set_input_pin(codec, nid, i);
4453                         if (nid != ALC880_PIN_CD_NID &&
4454                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4455                                 snd_hda_codec_write(codec, nid, 0,
4456                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4457                                                     AMP_OUT_MUTE);
4458                 }
4459         }
4460 }
4461
4462 /* parse the BIOS configuration and set up the alc_spec */
4463 /* return 1 if successful, 0 if the proper config is not found,
4464  * or a negative error code
4465  */
4466 static int alc880_parse_auto_config(struct hda_codec *codec)
4467 {
4468         struct alc_spec *spec = codec->spec;
4469         int i, err;
4470         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4471
4472         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4473                                            alc880_ignore);
4474         if (err < 0)
4475                 return err;
4476         if (!spec->autocfg.line_outs)
4477                 return 0; /* can't find valid BIOS pin config */
4478
4479         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4480         if (err < 0)
4481                 return err;
4482         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4483         if (err < 0)
4484                 return err;
4485         err = alc880_auto_create_extra_out(spec,
4486                                            spec->autocfg.speaker_pins[0],
4487                                            "Speaker");
4488         if (err < 0)
4489                 return err;
4490         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4491                                            "Headphone");
4492         if (err < 0)
4493                 return err;
4494         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
4495         if (err < 0)
4496                 return err;
4497
4498         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4499
4500         /* check multiple SPDIF-out (for recent codecs) */
4501         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4502                 hda_nid_t dig_nid;
4503                 err = snd_hda_get_connections(codec,
4504                                               spec->autocfg.dig_out_pins[i],
4505                                               &dig_nid, 1);
4506                 if (err < 0)
4507                         continue;
4508                 if (!i)
4509                         spec->multiout.dig_out_nid = dig_nid;
4510                 else {
4511                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4512                         spec->slave_dig_outs[i - 1] = dig_nid;
4513                         if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
4514                                 break;
4515                 }
4516         }
4517         if (spec->autocfg.dig_in_pin)
4518                 spec->dig_in_nid = ALC880_DIGIN_NID;
4519
4520         if (spec->kctls.list)
4521                 add_mixer(spec, spec->kctls.list);
4522
4523         add_verb(spec, alc880_volume_init_verbs);
4524
4525         spec->num_mux_defs = 1;
4526         spec->input_mux = &spec->private_imux[0];
4527
4528         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
4529
4530         return 1;
4531 }
4532
4533 /* additional initialization for auto-configuration model */
4534 static void alc880_auto_init(struct hda_codec *codec)
4535 {
4536         struct alc_spec *spec = codec->spec;
4537         alc880_auto_init_multi_out(codec);
4538         alc880_auto_init_extra_out(codec);
4539         alc880_auto_init_analog_input(codec);
4540         if (spec->unsol_event)
4541                 alc_inithook(codec);
4542 }
4543
4544 static void set_capture_mixer(struct alc_spec *spec)
4545 {
4546         static struct snd_kcontrol_new *caps[2][3] = {
4547                 { alc_capture_mixer_nosrc1,
4548                   alc_capture_mixer_nosrc2,
4549                   alc_capture_mixer_nosrc3 },
4550                 { alc_capture_mixer1,
4551                   alc_capture_mixer2,
4552                   alc_capture_mixer3 },
4553         };
4554         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4555                 int mux;
4556                 if (spec->input_mux && spec->input_mux->num_items > 1)
4557                         mux = 1;
4558                 else
4559                         mux = 0;
4560                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4561         }
4562 }
4563
4564 #define set_beep_amp(spec, nid, idx, dir) \
4565         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4566
4567 /*
4568  * OK, here we have finally the patch for ALC880
4569  */
4570
4571 static int patch_alc880(struct hda_codec *codec)
4572 {
4573         struct alc_spec *spec;
4574         int board_config;
4575         int err;
4576
4577         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4578         if (spec == NULL)
4579                 return -ENOMEM;
4580
4581         codec->spec = spec;
4582
4583         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4584                                                   alc880_models,
4585                                                   alc880_cfg_tbl);
4586         if (board_config < 0) {
4587                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
4588                        "trying auto-probe from BIOS...\n", codec->chip_name);
4589                 board_config = ALC880_AUTO;
4590         }
4591
4592         if (board_config == ALC880_AUTO) {
4593                 /* automatic parse from the BIOS config */
4594                 err = alc880_parse_auto_config(codec);
4595                 if (err < 0) {
4596                         alc_free(codec);
4597                         return err;
4598                 } else if (!err) {
4599                         printk(KERN_INFO
4600                                "hda_codec: Cannot set up configuration "
4601                                "from BIOS.  Using 3-stack mode...\n");
4602                         board_config = ALC880_3ST;
4603                 }
4604         }
4605
4606         err = snd_hda_attach_beep_device(codec, 0x1);
4607         if (err < 0) {
4608                 alc_free(codec);
4609                 return err;
4610         }
4611
4612         if (board_config != ALC880_AUTO)
4613                 setup_preset(spec, &alc880_presets[board_config]);
4614
4615         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4616         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4617         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4618
4619         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4620         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4621
4622         if (!spec->adc_nids && spec->input_mux) {
4623                 /* check whether NID 0x07 is valid */
4624                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4625                 /* get type */
4626                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
4627                 if (wcap != AC_WID_AUD_IN) {
4628                         spec->adc_nids = alc880_adc_nids_alt;
4629                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4630                 } else {
4631                         spec->adc_nids = alc880_adc_nids;
4632                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4633                 }
4634         }
4635         set_capture_mixer(spec);
4636         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4637
4638         spec->vmaster_nid = 0x0c;
4639
4640         codec->patch_ops = alc_patch_ops;
4641         if (board_config == ALC880_AUTO)
4642                 spec->init_hook = alc880_auto_init;
4643 #ifdef CONFIG_SND_HDA_POWER_SAVE
4644         if (!spec->loopback.amplist)
4645                 spec->loopback.amplist = alc880_loopbacks;
4646 #endif
4647         codec->proc_widget_hook = print_realtek_coef;
4648
4649         return 0;
4650 }
4651
4652
4653 /*
4654  * ALC260 support
4655  */
4656
4657 static hda_nid_t alc260_dac_nids[1] = {
4658         /* front */
4659         0x02,
4660 };
4661
4662 static hda_nid_t alc260_adc_nids[1] = {
4663         /* ADC0 */
4664         0x04,
4665 };
4666
4667 static hda_nid_t alc260_adc_nids_alt[1] = {
4668         /* ADC1 */
4669         0x05,
4670 };
4671
4672 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4673  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4674  */
4675 static hda_nid_t alc260_dual_adc_nids[2] = {
4676         /* ADC0, ADC1 */
4677         0x04, 0x05
4678 };
4679
4680 #define ALC260_DIGOUT_NID       0x03
4681 #define ALC260_DIGIN_NID        0x06
4682
4683 static struct hda_input_mux alc260_capture_source = {
4684         .num_items = 4,
4685         .items = {
4686                 { "Mic", 0x0 },
4687                 { "Front Mic", 0x1 },
4688                 { "Line", 0x2 },
4689                 { "CD", 0x4 },
4690         },
4691 };
4692
4693 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4694  * headphone jack and the internal CD lines since these are the only pins at
4695  * which audio can appear.  For flexibility, also allow the option of
4696  * recording the mixer output on the second ADC (ADC0 doesn't have a
4697  * connection to the mixer output).
4698  */
4699 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4700         {
4701                 .num_items = 3,
4702                 .items = {
4703                         { "Mic/Line", 0x0 },
4704                         { "CD", 0x4 },
4705                         { "Headphone", 0x2 },
4706                 },
4707         },
4708         {
4709                 .num_items = 4,
4710                 .items = {
4711                         { "Mic/Line", 0x0 },
4712                         { "CD", 0x4 },
4713                         { "Headphone", 0x2 },
4714                         { "Mixer", 0x5 },
4715                 },
4716         },
4717
4718 };
4719
4720 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4721  * the Fujitsu S702x, but jacks are marked differently.
4722  */
4723 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4724         {
4725                 .num_items = 4,
4726                 .items = {
4727                         { "Mic", 0x0 },
4728                         { "Line", 0x2 },
4729                         { "CD", 0x4 },
4730                         { "Headphone", 0x5 },
4731                 },
4732         },
4733         {
4734                 .num_items = 5,
4735                 .items = {
4736                         { "Mic", 0x0 },
4737                         { "Line", 0x2 },
4738                         { "CD", 0x4 },
4739                         { "Headphone", 0x6 },
4740                         { "Mixer", 0x5 },
4741                 },
4742         },
4743 };
4744
4745 /* Maxdata Favorit 100XS */
4746 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
4747         {
4748                 .num_items = 2,
4749                 .items = {
4750                         { "Line/Mic", 0x0 },
4751                         { "CD", 0x4 },
4752                 },
4753         },
4754         {
4755                 .num_items = 3,
4756                 .items = {
4757                         { "Line/Mic", 0x0 },
4758                         { "CD", 0x4 },
4759                         { "Mixer", 0x5 },
4760                 },
4761         },
4762 };
4763
4764 /*
4765  * This is just place-holder, so there's something for alc_build_pcms to look
4766  * at when it calculates the maximum number of channels. ALC260 has no mixer
4767  * element which allows changing the channel mode, so the verb list is
4768  * never used.
4769  */
4770 static struct hda_channel_mode alc260_modes[1] = {
4771         { 2, NULL },
4772 };
4773
4774
4775 /* Mixer combinations
4776  *
4777  * basic: base_output + input + pc_beep + capture
4778  * HP: base_output + input + capture_alt
4779  * HP_3013: hp_3013 + input + capture
4780  * fujitsu: fujitsu + capture
4781  * acer: acer + capture
4782  */
4783
4784 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4785         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4786         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4787         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4788         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4789         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4790         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4791         { } /* end */
4792 };
4793
4794 static struct snd_kcontrol_new alc260_input_mixer[] = {
4795         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4796         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4797         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4798         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4799         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4800         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4801         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4802         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4803         { } /* end */
4804 };
4805
4806 /* update HP, line and mono out pins according to the master switch */
4807 static void alc260_hp_master_update(struct hda_codec *codec,
4808                                     hda_nid_t hp, hda_nid_t line,
4809                                     hda_nid_t mono)
4810 {
4811         struct alc_spec *spec = codec->spec;
4812         unsigned int val = spec->master_sw ? PIN_HP : 0;
4813         /* change HP and line-out pins */
4814         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4815                             val);
4816         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4817                             val);
4818         /* mono (speaker) depending on the HP jack sense */
4819         val = (val && !spec->jack_present) ? PIN_OUT : 0;
4820         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4821                             val);
4822 }
4823
4824 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4825                                    struct snd_ctl_elem_value *ucontrol)
4826 {
4827         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4828         struct alc_spec *spec = codec->spec;
4829         *ucontrol->value.integer.value = spec->master_sw;
4830         return 0;
4831 }
4832
4833 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4834                                    struct snd_ctl_elem_value *ucontrol)
4835 {
4836         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4837         struct alc_spec *spec = codec->spec;
4838         int val = !!*ucontrol->value.integer.value;
4839         hda_nid_t hp, line, mono;
4840
4841         if (val == spec->master_sw)
4842                 return 0;
4843         spec->master_sw = val;
4844         hp = (kcontrol->private_value >> 16) & 0xff;
4845         line = (kcontrol->private_value >> 8) & 0xff;
4846         mono = kcontrol->private_value & 0xff;
4847         alc260_hp_master_update(codec, hp, line, mono);
4848         return 1;
4849 }
4850
4851 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4852         {
4853                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4854                 .name = "Master Playback Switch",
4855                 .info = snd_ctl_boolean_mono_info,
4856                 .get = alc260_hp_master_sw_get,
4857                 .put = alc260_hp_master_sw_put,
4858                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4859         },
4860         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4861         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4862         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4863         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4864         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4865                               HDA_OUTPUT),
4866         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4867         { } /* end */
4868 };
4869
4870 static struct hda_verb alc260_hp_unsol_verbs[] = {
4871         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4872         {},
4873 };
4874
4875 static void alc260_hp_automute(struct hda_codec *codec)
4876 {
4877         struct alc_spec *spec = codec->spec;
4878         unsigned int present;
4879
4880         present = snd_hda_codec_read(codec, 0x10, 0,
4881                                      AC_VERB_GET_PIN_SENSE, 0);
4882         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4883         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4884 }
4885
4886 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4887 {
4888         if ((res >> 26) == ALC880_HP_EVENT)
4889                 alc260_hp_automute(codec);
4890 }
4891
4892 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4893         {
4894                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4895                 .name = "Master Playback Switch",
4896                 .info = snd_ctl_boolean_mono_info,
4897                 .get = alc260_hp_master_sw_get,
4898                 .put = alc260_hp_master_sw_put,
4899                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
4900         },
4901         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4902         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4903         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4904         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4905         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4906         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4907         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4908         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4909         { } /* end */
4910 };
4911
4912 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4913         .ops = &snd_hda_bind_vol,
4914         .values = {
4915                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4916                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4917                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4918                 0
4919         },
4920 };
4921
4922 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4923         .ops = &snd_hda_bind_sw,
4924         .values = {
4925                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4926                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4927                 0
4928         },
4929 };
4930
4931 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4932         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4933         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4934         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4935         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4936         { } /* end */
4937 };
4938
4939 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4940         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4941         {},
4942 };
4943
4944 static void alc260_hp_3013_automute(struct hda_codec *codec)
4945 {
4946         struct alc_spec *spec = codec->spec;
4947         unsigned int present;
4948
4949         present = snd_hda_codec_read(codec, 0x15, 0,
4950                                      AC_VERB_GET_PIN_SENSE, 0);
4951         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4952         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
4953 }
4954
4955 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4956                                        unsigned int res)
4957 {
4958         if ((res >> 26) == ALC880_HP_EVENT)
4959                 alc260_hp_3013_automute(codec);
4960 }
4961
4962 static void alc260_hp_3012_automute(struct hda_codec *codec)
4963 {
4964         unsigned int present, bits;
4965
4966         present = snd_hda_codec_read(codec, 0x10, 0,
4967                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4968
4969         bits = present ? 0 : PIN_OUT;
4970         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4971                             bits);
4972         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4973                             bits);
4974         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4975                             bits);
4976 }
4977
4978 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4979                                        unsigned int res)
4980 {
4981         if ((res >> 26) == ALC880_HP_EVENT)
4982                 alc260_hp_3012_automute(codec);
4983 }
4984
4985 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
4986  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
4987  */
4988 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4989         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4990         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4991         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4992         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4993         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4994         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4995         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4996         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4997         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4998         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4999         { } /* end */
5000 };
5001
5002 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5003  * versions of the ALC260 don't act on requests to enable mic bias from NID
5004  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5005  * datasheet doesn't mention this restriction.  At this stage it's not clear
5006  * whether this behaviour is intentional or is a hardware bug in chip
5007  * revisions available in early 2006.  Therefore for now allow the
5008  * "Headphone Jack Mode" control to span all choices, but if it turns out
5009  * that the lack of mic bias for this NID is intentional we could change the
5010  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5011  *
5012  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5013  * don't appear to make the mic bias available from the "line" jack, even
5014  * though the NID used for this jack (0x14) can supply it.  The theory is
5015  * that perhaps Acer have included blocking capacitors between the ALC260
5016  * and the output jack.  If this turns out to be the case for all such
5017  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5018  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5019  *
5020  * The C20x Tablet series have a mono internal speaker which is controlled
5021  * via the chip's Mono sum widget and pin complex, so include the necessary
5022  * controls for such models.  On models without a "mono speaker" the control
5023  * won't do anything.
5024  */
5025 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5026         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5027         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5028         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5029         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5030                               HDA_OUTPUT),
5031         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5032                            HDA_INPUT),
5033         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5034         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5035         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5036         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5037         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5038         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5039         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5040         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5041         { } /* end */
5042 };
5043
5044 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5045  */
5046 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5047         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5048         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5049         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5050         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5051         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5052         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5053         { } /* end */
5054 };
5055
5056 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5057  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5058  */
5059 static struct snd_kcontrol_new alc260_will_mixer[] = {
5060         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5061         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5062         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5063         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5064         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5065         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5066         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5067         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5068         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5069         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5070         { } /* end */
5071 };
5072
5073 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5074  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5075  */
5076 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5077         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5078         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5079         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5080         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5081         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5082         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
5083         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
5084         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5085         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5086         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5087         { } /* end */
5088 };
5089
5090 /*
5091  * initialization verbs
5092  */
5093 static struct hda_verb alc260_init_verbs[] = {
5094         /* Line In pin widget for input */
5095         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5096         /* CD pin widget for input */
5097         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5098         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5099         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5100         /* Mic2 (front panel) pin widget for input and vref at 80% */
5101         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5102         /* LINE-2 is used for line-out in rear */
5103         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5104         /* select line-out */
5105         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
5106         /* LINE-OUT pin */
5107         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5108         /* enable HP */
5109         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5110         /* enable Mono */
5111         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5112         /* mute capture amp left and right */
5113         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5114         /* set connection select to line in (default select for this ADC) */
5115         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5116         /* mute capture amp left and right */
5117         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5118         /* set connection select to line in (default select for this ADC) */
5119         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
5120         /* set vol=0 Line-Out mixer amp left and right */
5121         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5122         /* unmute pin widget amp left and right (no gain on this amp) */
5123         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5124         /* set vol=0 HP mixer amp left and right */
5125         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5126         /* unmute pin widget amp left and right (no gain on this amp) */
5127         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5128         /* set vol=0 Mono mixer amp left and right */
5129         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5130         /* unmute pin widget amp left and right (no gain on this amp) */
5131         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5132         /* unmute LINE-2 out pin */
5133         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5134         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5135          * Line In 2 = 0x03
5136          */
5137         /* mute analog inputs */
5138         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5139         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5140         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5141         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5142         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5143         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5144         /* mute Front out path */
5145         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5146         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5147         /* mute Headphone out path */
5148         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5149         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5150         /* mute Mono out path */
5151         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5152         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5153         { }
5154 };
5155
5156 #if 0 /* should be identical with alc260_init_verbs? */
5157 static struct hda_verb alc260_hp_init_verbs[] = {
5158         /* Headphone and output */
5159         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5160         /* mono output */
5161         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5162         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5163         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5164         /* Mic2 (front panel) pin widget for input and vref at 80% */
5165         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5166         /* Line In pin widget for input */
5167         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5168         /* Line-2 pin widget for output */
5169         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5170         /* CD pin widget for input */
5171         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5172         /* unmute amp left and right */
5173         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5174         /* set connection select to line in (default select for this ADC) */
5175         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5176         /* unmute Line-Out mixer amp left and right (volume = 0) */
5177         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5178         /* mute pin widget amp left and right (no gain on this amp) */
5179         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5180         /* unmute HP mixer amp left and right (volume = 0) */
5181         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5182         /* mute pin widget amp left and right (no gain on this amp) */
5183         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5184         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5185          * Line In 2 = 0x03
5186          */
5187         /* mute analog inputs */
5188         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5189         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5190         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5191         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5192         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5193         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5194         /* Unmute Front out path */
5195         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5196         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5197         /* Unmute Headphone out path */
5198         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5199         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5200         /* Unmute Mono out path */
5201         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5202         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5203         { }
5204 };
5205 #endif
5206
5207 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5208         /* Line out and output */
5209         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5210         /* mono output */
5211         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5212         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5213         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5214         /* Mic2 (front panel) pin widget for input and vref at 80% */
5215         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5216         /* Line In pin widget for input */
5217         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5218         /* Headphone pin widget for output */
5219         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5220         /* CD pin widget for input */
5221         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5222         /* unmute amp left and right */
5223         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5224         /* set connection select to line in (default select for this ADC) */
5225         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5226         /* unmute Line-Out mixer amp left and right (volume = 0) */
5227         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5228         /* mute pin widget amp left and right (no gain on this amp) */
5229         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5230         /* unmute HP mixer amp left and right (volume = 0) */
5231         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5232         /* mute pin widget amp left and right (no gain on this amp) */
5233         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5234         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5235          * Line In 2 = 0x03
5236          */
5237         /* mute analog inputs */
5238         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5239         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5240         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5241         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5242         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5243         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5244         /* Unmute Front out path */
5245         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5246         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5247         /* Unmute Headphone out path */
5248         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5249         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5250         /* Unmute Mono out path */
5251         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5252         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5253         { }
5254 };
5255
5256 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5257  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5258  * audio = 0x16, internal speaker = 0x10.
5259  */
5260 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5261         /* Disable all GPIOs */
5262         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5263         /* Internal speaker is connected to headphone pin */
5264         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5265         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5266         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5267         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5268         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5269         /* Ensure all other unused pins are disabled and muted. */
5270         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5271         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5272         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5273         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5274         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5275         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5276         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5277         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5278
5279         /* Disable digital (SPDIF) pins */
5280         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5281         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5282
5283         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5284          * when acting as an output.
5285          */
5286         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5287
5288         /* Start with output sum widgets muted and their output gains at min */
5289         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5290         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5291         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5292         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5293         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5294         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5295         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5296         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5297         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5298
5299         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5300         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5301         /* Unmute Line1 pin widget output buffer since it starts as an output.
5302          * If the pin mode is changed by the user the pin mode control will
5303          * take care of enabling the pin's input/output buffers as needed.
5304          * Therefore there's no need to enable the input buffer at this
5305          * stage.
5306          */
5307         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5308         /* Unmute input buffer of pin widget used for Line-in (no equiv
5309          * mixer ctrl)
5310          */
5311         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5312
5313         /* Mute capture amp left and right */
5314         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5315         /* Set ADC connection select to match default mixer setting - line
5316          * in (on mic1 pin)
5317          */
5318         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5319
5320         /* Do the same for the second ADC: mute capture input amp and
5321          * set ADC connection to line in (on mic1 pin)
5322          */
5323         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5324         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5325
5326         /* Mute all inputs to mixer widget (even unconnected ones) */
5327         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5328         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5329         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5330         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5331         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5332         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5333         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5334         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5335
5336         { }
5337 };
5338
5339 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5340  * similar laptops (adapted from Fujitsu init verbs).
5341  */
5342 static struct hda_verb alc260_acer_init_verbs[] = {
5343         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5344          * the headphone jack.  Turn this on and rely on the standard mute
5345          * methods whenever the user wants to turn these outputs off.
5346          */
5347         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5348         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5349         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5350         /* Internal speaker/Headphone jack is connected to Line-out pin */
5351         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5352         /* Internal microphone/Mic jack is connected to Mic1 pin */
5353         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5354         /* Line In jack is connected to Line1 pin */
5355         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5356         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5357         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5358         /* Ensure all other unused pins are disabled and muted. */
5359         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5360         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5361         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5362         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5363         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5364         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5365         /* Disable digital (SPDIF) pins */
5366         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5367         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5368
5369         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5370          * bus when acting as outputs.
5371          */
5372         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5373         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5374
5375         /* Start with output sum widgets muted and their output gains at min */
5376         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5377         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5378         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5379         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5380         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5381         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5382         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5383         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5384         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5385
5386         /* Unmute Line-out pin widget amp left and right
5387          * (no equiv mixer ctrl)
5388          */
5389         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5390         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5391         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5392         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5393          * inputs. If the pin mode is changed by the user the pin mode control
5394          * will take care of enabling the pin's input/output buffers as needed.
5395          * Therefore there's no need to enable the input buffer at this
5396          * stage.
5397          */
5398         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5399         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5400
5401         /* Mute capture amp left and right */
5402         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5403         /* Set ADC connection select to match default mixer setting - mic
5404          * (on mic1 pin)
5405          */
5406         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5407
5408         /* Do similar with the second ADC: mute capture input amp and
5409          * set ADC connection to mic to match ALSA's default state.
5410          */
5411         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5412         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5413
5414         /* Mute all inputs to mixer widget (even unconnected ones) */
5415         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5416         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5417         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5418         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5419         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5420         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5421         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5422         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5423
5424         { }
5425 };
5426
5427 /* Initialisation sequence for Maxdata Favorit 100XS
5428  * (adapted from Acer init verbs).
5429  */
5430 static struct hda_verb alc260_favorit100_init_verbs[] = {
5431         /* GPIO 0 enables the output jack.
5432          * Turn this on and rely on the standard mute
5433          * methods whenever the user wants to turn these outputs off.
5434          */
5435         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5436         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5437         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5438         /* Line/Mic input jack is connected to Mic1 pin */
5439         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5440         /* Ensure all other unused pins are disabled and muted. */
5441         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5442         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5443         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5444         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5445         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5446         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5447         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5448         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5449         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5450         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5451         /* Disable digital (SPDIF) pins */
5452         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5453         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5454
5455         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5456          * bus when acting as outputs.
5457          */
5458         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5459         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5460
5461         /* Start with output sum widgets muted and their output gains at min */
5462         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5463         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5464         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5465         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5466         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5467         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5468         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5469         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5470         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5471
5472         /* Unmute Line-out pin widget amp left and right
5473          * (no equiv mixer ctrl)
5474          */
5475         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5476         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5477          * inputs. If the pin mode is changed by the user the pin mode control
5478          * will take care of enabling the pin's input/output buffers as needed.
5479          * Therefore there's no need to enable the input buffer at this
5480          * stage.
5481          */
5482         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5483
5484         /* Mute capture amp left and right */
5485         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5486         /* Set ADC connection select to match default mixer setting - mic
5487          * (on mic1 pin)
5488          */
5489         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5490
5491         /* Do similar with the second ADC: mute capture input amp and
5492          * set ADC connection to mic to match ALSA's default state.
5493          */
5494         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5495         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5496
5497         /* Mute all inputs to mixer widget (even unconnected ones) */
5498         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5499         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5500         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5501         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5502         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5503         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5504         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5505         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5506
5507         { }
5508 };
5509
5510 static struct hda_verb alc260_will_verbs[] = {
5511         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5512         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5513         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5514         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5515         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5516         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5517         {}
5518 };
5519
5520 static struct hda_verb alc260_replacer_672v_verbs[] = {
5521         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5522         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5523         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5524
5525         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5526         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5527         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5528
5529         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5530         {}
5531 };
5532
5533 /* toggle speaker-output according to the hp-jack state */
5534 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5535 {
5536         unsigned int present;
5537
5538         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5539         present = snd_hda_codec_read(codec, 0x0f, 0,
5540                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5541         if (present) {
5542                 snd_hda_codec_write_cache(codec, 0x01, 0,
5543                                           AC_VERB_SET_GPIO_DATA, 1);
5544                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5545                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5546                                           PIN_HP);
5547         } else {
5548                 snd_hda_codec_write_cache(codec, 0x01, 0,
5549                                           AC_VERB_SET_GPIO_DATA, 0);
5550                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5551                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5552                                           PIN_OUT);
5553         }
5554 }
5555
5556 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5557                                        unsigned int res)
5558 {
5559         if ((res >> 26) == ALC880_HP_EVENT)
5560                 alc260_replacer_672v_automute(codec);
5561 }
5562
5563 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5564         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5565         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5566         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5567         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5568         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5569         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5570         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5571         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5572         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5573         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5574         {}
5575 };
5576
5577 /* Test configuration for debugging, modelled after the ALC880 test
5578  * configuration.
5579  */
5580 #ifdef CONFIG_SND_DEBUG
5581 static hda_nid_t alc260_test_dac_nids[1] = {
5582         0x02,
5583 };
5584 static hda_nid_t alc260_test_adc_nids[2] = {
5585         0x04, 0x05,
5586 };
5587 /* For testing the ALC260, each input MUX needs its own definition since
5588  * the signal assignments are different.  This assumes that the first ADC
5589  * is NID 0x04.
5590  */
5591 static struct hda_input_mux alc260_test_capture_sources[2] = {
5592         {
5593                 .num_items = 7,
5594                 .items = {
5595                         { "MIC1 pin", 0x0 },
5596                         { "MIC2 pin", 0x1 },
5597                         { "LINE1 pin", 0x2 },
5598                         { "LINE2 pin", 0x3 },
5599                         { "CD pin", 0x4 },
5600                         { "LINE-OUT pin", 0x5 },
5601                         { "HP-OUT pin", 0x6 },
5602                 },
5603         },
5604         {
5605                 .num_items = 8,
5606                 .items = {
5607                         { "MIC1 pin", 0x0 },
5608                         { "MIC2 pin", 0x1 },
5609                         { "LINE1 pin", 0x2 },
5610                         { "LINE2 pin", 0x3 },
5611                         { "CD pin", 0x4 },
5612                         { "Mixer", 0x5 },
5613                         { "LINE-OUT pin", 0x6 },
5614                         { "HP-OUT pin", 0x7 },
5615                 },
5616         },
5617 };
5618 static struct snd_kcontrol_new alc260_test_mixer[] = {
5619         /* Output driver widgets */
5620         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5621         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5622         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5623         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5624         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5625         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5626
5627         /* Modes for retasking pin widgets
5628          * Note: the ALC260 doesn't seem to act on requests to enable mic
5629          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5630          * mention this restriction.  At this stage it's not clear whether
5631          * this behaviour is intentional or is a hardware bug in chip
5632          * revisions available at least up until early 2006.  Therefore for
5633          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5634          * choices, but if it turns out that the lack of mic bias for these
5635          * NIDs is intentional we could change their modes from
5636          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5637          */
5638         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5639         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5640         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5641         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5642         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5643         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5644
5645         /* Loopback mixer controls */
5646         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5647         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5648         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5649         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5650         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5651         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5652         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5653         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5654         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5655         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5656         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5657         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5658         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5659         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5660
5661         /* Controls for GPIO pins, assuming they are configured as outputs */
5662         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5663         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5664         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5665         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5666
5667         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5668          * is ambigious as to which NID is which; testing on laptops which
5669          * make this output available should provide clarification.
5670          */
5671         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5672         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5673
5674         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5675          * this output to turn on an external amplifier.
5676          */
5677         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5678         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5679
5680         { } /* end */
5681 };
5682 static struct hda_verb alc260_test_init_verbs[] = {
5683         /* Enable all GPIOs as outputs with an initial value of 0 */
5684         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5685         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5686         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5687
5688         /* Enable retasking pins as output, initially without power amp */
5689         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5690         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5691         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5692         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5693         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5694         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5695
5696         /* Disable digital (SPDIF) pins initially, but users can enable
5697          * them via a mixer switch.  In the case of SPDIF-out, this initverb
5698          * payload also sets the generation to 0, output to be in "consumer"
5699          * PCM format, copyright asserted, no pre-emphasis and no validity
5700          * control.
5701          */
5702         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5703         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5704
5705         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5706          * OUT1 sum bus when acting as an output.
5707          */
5708         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5709         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5710         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5711         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5712
5713         /* Start with output sum widgets muted and their output gains at min */
5714         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5715         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5716         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5717         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5718         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5719         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5720         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5721         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5722         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5723
5724         /* Unmute retasking pin widget output buffers since the default
5725          * state appears to be output.  As the pin mode is changed by the
5726          * user the pin mode control will take care of enabling the pin's
5727          * input/output buffers as needed.
5728          */
5729         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5730         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5731         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5732         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5733         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5734         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5735         /* Also unmute the mono-out pin widget */
5736         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5737
5738         /* Mute capture amp left and right */
5739         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5740         /* Set ADC connection select to match default mixer setting (mic1
5741          * pin)
5742          */
5743         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5744
5745         /* Do the same for the second ADC: mute capture input amp and
5746          * set ADC connection to mic1 pin
5747          */
5748         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5749         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5750
5751         /* Mute all inputs to mixer widget (even unconnected ones) */
5752         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5753         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5754         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5755         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5756         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5757         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5758         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5759         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5760
5761         { }
5762 };
5763 #endif
5764
5765 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
5766 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
5767
5768 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
5769 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
5770
5771 /*
5772  * for BIOS auto-configuration
5773  */
5774
5775 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5776                                         const char *pfx, int *vol_bits)
5777 {
5778         hda_nid_t nid_vol;
5779         unsigned long vol_val, sw_val;
5780         char name[32];
5781         int err;
5782
5783         if (nid >= 0x0f && nid < 0x11) {
5784                 nid_vol = nid - 0x7;
5785                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5786                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5787         } else if (nid == 0x11) {
5788                 nid_vol = nid - 0x7;
5789                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5790                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5791         } else if (nid >= 0x12 && nid <= 0x15) {
5792                 nid_vol = 0x08;
5793                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5794                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5795         } else
5796                 return 0; /* N/A */
5797
5798         if (!(*vol_bits & (1 << nid_vol))) {
5799                 /* first control for the volume widget */
5800                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5801                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5802                 if (err < 0)
5803                         return err;
5804                 *vol_bits |= (1 << nid_vol);
5805         }
5806         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5807         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5808         if (err < 0)
5809                 return err;
5810         return 1;
5811 }
5812
5813 /* add playback controls from the parsed DAC table */
5814 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5815                                              const struct auto_pin_cfg *cfg)
5816 {
5817         hda_nid_t nid;
5818         int err;
5819         int vols = 0;
5820
5821         spec->multiout.num_dacs = 1;
5822         spec->multiout.dac_nids = spec->private_dac_nids;
5823         spec->multiout.dac_nids[0] = 0x02;
5824
5825         nid = cfg->line_out_pins[0];
5826         if (nid) {
5827                 err = alc260_add_playback_controls(spec, nid, "Front", &vols);
5828                 if (err < 0)
5829                         return err;
5830         }
5831
5832         nid = cfg->speaker_pins[0];
5833         if (nid) {
5834                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
5835                 if (err < 0)
5836                         return err;
5837         }
5838
5839         nid = cfg->hp_pins[0];
5840         if (nid) {
5841                 err = alc260_add_playback_controls(spec, nid, "Headphone",
5842                                                    &vols);
5843                 if (err < 0)
5844                         return err;
5845         }
5846         return 0;
5847 }
5848
5849 /* create playback/capture controls for input pins */
5850 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5851                                                 const struct auto_pin_cfg *cfg)
5852 {
5853         struct hda_input_mux *imux = &spec->private_imux[0];
5854         int i, err, idx;
5855
5856         for (i = 0; i < AUTO_PIN_LAST; i++) {
5857                 if (cfg->input_pins[i] >= 0x12) {
5858                         idx = cfg->input_pins[i] - 0x12;
5859                         err = new_analog_input(spec, cfg->input_pins[i],
5860                                                auto_pin_cfg_labels[i], idx,
5861                                                0x07);
5862                         if (err < 0)
5863                                 return err;
5864                         imux->items[imux->num_items].label =
5865                                 auto_pin_cfg_labels[i];
5866                         imux->items[imux->num_items].index = idx;
5867                         imux->num_items++;
5868                 }
5869                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5870                         idx = cfg->input_pins[i] - 0x09;
5871                         err = new_analog_input(spec, cfg->input_pins[i],
5872                                                auto_pin_cfg_labels[i], idx,
5873                                                0x07);
5874                         if (err < 0)
5875                                 return err;
5876                         imux->items[imux->num_items].label =
5877                                 auto_pin_cfg_labels[i];
5878                         imux->items[imux->num_items].index = idx;
5879                         imux->num_items++;
5880                 }
5881         }
5882         return 0;
5883 }
5884
5885 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5886                                               hda_nid_t nid, int pin_type,
5887                                               int sel_idx)
5888 {
5889         alc_set_pin_output(codec, nid, pin_type);
5890         /* need the manual connection? */
5891         if (nid >= 0x12) {
5892                 int idx = nid - 0x12;
5893                 snd_hda_codec_write(codec, idx + 0x0b, 0,
5894                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
5895         }
5896 }
5897
5898 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5899 {
5900         struct alc_spec *spec = codec->spec;
5901         hda_nid_t nid;
5902
5903         nid = spec->autocfg.line_out_pins[0];
5904         if (nid) {
5905                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5906                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5907         }
5908
5909         nid = spec->autocfg.speaker_pins[0];
5910         if (nid)
5911                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5912
5913         nid = spec->autocfg.hp_pins[0];
5914         if (nid)
5915                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5916 }
5917
5918 #define ALC260_PIN_CD_NID               0x16
5919 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5920 {
5921         struct alc_spec *spec = codec->spec;
5922         int i;
5923
5924         for (i = 0; i < AUTO_PIN_LAST; i++) {
5925                 hda_nid_t nid = spec->autocfg.input_pins[i];
5926                 if (nid >= 0x12) {
5927                         alc_set_input_pin(codec, nid, i);
5928                         if (nid != ALC260_PIN_CD_NID &&
5929                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5930                                 snd_hda_codec_write(codec, nid, 0,
5931                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5932                                                     AMP_OUT_MUTE);
5933                 }
5934         }
5935 }
5936
5937 /*
5938  * generic initialization of ADC, input mixers and output mixers
5939  */
5940 static struct hda_verb alc260_volume_init_verbs[] = {
5941         /*
5942          * Unmute ADC0-1 and set the default input to mic-in
5943          */
5944         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5945         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5946         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5947         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5948
5949         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5950          * mixer widget
5951          * Note: PASD motherboards uses the Line In 2 as the input for
5952          * front panel mic (mic 2)
5953          */
5954         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5955         /* mute analog inputs */
5956         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5957         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5958         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5959         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5960         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5961
5962         /*
5963          * Set up output mixers (0x08 - 0x0a)
5964          */
5965         /* set vol=0 to output mixers */
5966         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5967         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5968         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5969         /* set up input amps for analog loopback */
5970         /* Amp Indices: DAC = 0, mixer = 1 */
5971         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5972         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5973         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5974         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5975         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5976         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5977
5978         { }
5979 };
5980
5981 static int alc260_parse_auto_config(struct hda_codec *codec)
5982 {
5983         struct alc_spec *spec = codec->spec;
5984         int err;
5985         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5986
5987         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5988                                            alc260_ignore);
5989         if (err < 0)
5990                 return err;
5991         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5992         if (err < 0)
5993                 return err;
5994         if (!spec->kctls.list)
5995                 return 0; /* can't find valid BIOS pin config */
5996         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5997         if (err < 0)
5998                 return err;
5999
6000         spec->multiout.max_channels = 2;
6001
6002         if (spec->autocfg.dig_outs)
6003                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6004         if (spec->kctls.list)
6005                 add_mixer(spec, spec->kctls.list);
6006
6007         add_verb(spec, alc260_volume_init_verbs);
6008
6009         spec->num_mux_defs = 1;
6010         spec->input_mux = &spec->private_imux[0];
6011
6012         alc_ssid_check(codec, 0x10, 0x15, 0x0f);
6013
6014         return 1;
6015 }
6016
6017 /* additional initialization for auto-configuration model */
6018 static void alc260_auto_init(struct hda_codec *codec)
6019 {
6020         struct alc_spec *spec = codec->spec;
6021         alc260_auto_init_multi_out(codec);
6022         alc260_auto_init_analog_input(codec);
6023         if (spec->unsol_event)
6024                 alc_inithook(codec);
6025 }
6026
6027 #ifdef CONFIG_SND_HDA_POWER_SAVE
6028 static struct hda_amp_list alc260_loopbacks[] = {
6029         { 0x07, HDA_INPUT, 0 },
6030         { 0x07, HDA_INPUT, 1 },
6031         { 0x07, HDA_INPUT, 2 },
6032         { 0x07, HDA_INPUT, 3 },
6033         { 0x07, HDA_INPUT, 4 },
6034         { } /* end */
6035 };
6036 #endif
6037
6038 /*
6039  * ALC260 configurations
6040  */
6041 static const char *alc260_models[ALC260_MODEL_LAST] = {
6042         [ALC260_BASIC]          = "basic",
6043         [ALC260_HP]             = "hp",
6044         [ALC260_HP_3013]        = "hp-3013",
6045         [ALC260_HP_DC7600]      = "hp-dc7600",
6046         [ALC260_FUJITSU_S702X]  = "fujitsu",
6047         [ALC260_ACER]           = "acer",
6048         [ALC260_WILL]           = "will",
6049         [ALC260_REPLACER_672V]  = "replacer",
6050         [ALC260_FAVORIT100]     = "favorit100",
6051 #ifdef CONFIG_SND_DEBUG
6052         [ALC260_TEST]           = "test",
6053 #endif
6054         [ALC260_AUTO]           = "auto",
6055 };
6056
6057 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6058         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6059         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6060         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6061         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6062         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
6063         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6064         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6065         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6066         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6067         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6068         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6069         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6070         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6071         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6072         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6073         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6074         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6075         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6076         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6077         {}
6078 };
6079
6080 static struct alc_config_preset alc260_presets[] = {
6081         [ALC260_BASIC] = {
6082                 .mixers = { alc260_base_output_mixer,
6083                             alc260_input_mixer },
6084                 .init_verbs = { alc260_init_verbs },
6085                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6086                 .dac_nids = alc260_dac_nids,
6087                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6088                 .adc_nids = alc260_adc_nids,
6089                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6090                 .channel_mode = alc260_modes,
6091                 .input_mux = &alc260_capture_source,
6092         },
6093         [ALC260_HP] = {
6094                 .mixers = { alc260_hp_output_mixer,
6095                             alc260_input_mixer },
6096                 .init_verbs = { alc260_init_verbs,
6097                                 alc260_hp_unsol_verbs },
6098                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6099                 .dac_nids = alc260_dac_nids,
6100                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6101                 .adc_nids = alc260_adc_nids_alt,
6102                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6103                 .channel_mode = alc260_modes,
6104                 .input_mux = &alc260_capture_source,
6105                 .unsol_event = alc260_hp_unsol_event,
6106                 .init_hook = alc260_hp_automute,
6107         },
6108         [ALC260_HP_DC7600] = {
6109                 .mixers = { alc260_hp_dc7600_mixer,
6110                             alc260_input_mixer },
6111                 .init_verbs = { alc260_init_verbs,
6112                                 alc260_hp_dc7600_verbs },
6113                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6114                 .dac_nids = alc260_dac_nids,
6115                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6116                 .adc_nids = alc260_adc_nids_alt,
6117                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6118                 .channel_mode = alc260_modes,
6119                 .input_mux = &alc260_capture_source,
6120                 .unsol_event = alc260_hp_3012_unsol_event,
6121                 .init_hook = alc260_hp_3012_automute,
6122         },
6123         [ALC260_HP_3013] = {
6124                 .mixers = { alc260_hp_3013_mixer,
6125                             alc260_input_mixer },
6126                 .init_verbs = { alc260_hp_3013_init_verbs,
6127                                 alc260_hp_3013_unsol_verbs },
6128                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6129                 .dac_nids = alc260_dac_nids,
6130                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6131                 .adc_nids = alc260_adc_nids_alt,
6132                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6133                 .channel_mode = alc260_modes,
6134                 .input_mux = &alc260_capture_source,
6135                 .unsol_event = alc260_hp_3013_unsol_event,
6136                 .init_hook = alc260_hp_3013_automute,
6137         },
6138         [ALC260_FUJITSU_S702X] = {
6139                 .mixers = { alc260_fujitsu_mixer },
6140                 .init_verbs = { alc260_fujitsu_init_verbs },
6141                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6142                 .dac_nids = alc260_dac_nids,
6143                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6144                 .adc_nids = alc260_dual_adc_nids,
6145                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6146                 .channel_mode = alc260_modes,
6147                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
6148                 .input_mux = alc260_fujitsu_capture_sources,
6149         },
6150         [ALC260_ACER] = {
6151                 .mixers = { alc260_acer_mixer },
6152                 .init_verbs = { alc260_acer_init_verbs },
6153                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6154                 .dac_nids = alc260_dac_nids,
6155                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6156                 .adc_nids = alc260_dual_adc_nids,
6157                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6158                 .channel_mode = alc260_modes,
6159                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
6160                 .input_mux = alc260_acer_capture_sources,
6161         },
6162         [ALC260_FAVORIT100] = {
6163                 .mixers = { alc260_favorit100_mixer },
6164                 .init_verbs = { alc260_favorit100_init_verbs },
6165                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6166                 .dac_nids = alc260_dac_nids,
6167                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6168                 .adc_nids = alc260_dual_adc_nids,
6169                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6170                 .channel_mode = alc260_modes,
6171                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6172                 .input_mux = alc260_favorit100_capture_sources,
6173         },
6174         [ALC260_WILL] = {
6175                 .mixers = { alc260_will_mixer },
6176                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
6177                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6178                 .dac_nids = alc260_dac_nids,
6179                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6180                 .adc_nids = alc260_adc_nids,
6181                 .dig_out_nid = ALC260_DIGOUT_NID,
6182                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6183                 .channel_mode = alc260_modes,
6184                 .input_mux = &alc260_capture_source,
6185         },
6186         [ALC260_REPLACER_672V] = {
6187                 .mixers = { alc260_replacer_672v_mixer },
6188                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6189                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6190                 .dac_nids = alc260_dac_nids,
6191                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6192                 .adc_nids = alc260_adc_nids,
6193                 .dig_out_nid = ALC260_DIGOUT_NID,
6194                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6195                 .channel_mode = alc260_modes,
6196                 .input_mux = &alc260_capture_source,
6197                 .unsol_event = alc260_replacer_672v_unsol_event,
6198                 .init_hook = alc260_replacer_672v_automute,
6199         },
6200 #ifdef CONFIG_SND_DEBUG
6201         [ALC260_TEST] = {
6202                 .mixers = { alc260_test_mixer },
6203                 .init_verbs = { alc260_test_init_verbs },
6204                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6205                 .dac_nids = alc260_test_dac_nids,
6206                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6207                 .adc_nids = alc260_test_adc_nids,
6208                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6209                 .channel_mode = alc260_modes,
6210                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6211                 .input_mux = alc260_test_capture_sources,
6212         },
6213 #endif
6214 };
6215
6216 static int patch_alc260(struct hda_codec *codec)
6217 {
6218         struct alc_spec *spec;
6219         int err, board_config;
6220
6221         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6222         if (spec == NULL)
6223                 return -ENOMEM;
6224
6225         codec->spec = spec;
6226
6227         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6228                                                   alc260_models,
6229                                                   alc260_cfg_tbl);
6230         if (board_config < 0) {
6231                 snd_printd(KERN_INFO "hda_codec: Unknown model for %s, "
6232                            "trying auto-probe from BIOS...\n",
6233                            codec->chip_name);
6234                 board_config = ALC260_AUTO;
6235         }
6236
6237         if (board_config == ALC260_AUTO) {
6238                 /* automatic parse from the BIOS config */
6239                 err = alc260_parse_auto_config(codec);
6240                 if (err < 0) {
6241                         alc_free(codec);
6242                         return err;
6243                 } else if (!err) {
6244                         printk(KERN_INFO
6245                                "hda_codec: Cannot set up configuration "
6246                                "from BIOS.  Using base mode...\n");
6247                         board_config = ALC260_BASIC;
6248                 }
6249         }
6250
6251         err = snd_hda_attach_beep_device(codec, 0x1);
6252         if (err < 0) {
6253                 alc_free(codec);
6254                 return err;
6255         }
6256
6257         if (board_config != ALC260_AUTO)
6258                 setup_preset(spec, &alc260_presets[board_config]);
6259
6260         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6261         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6262
6263         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6264         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6265
6266         if (!spec->adc_nids && spec->input_mux) {
6267                 /* check whether NID 0x04 is valid */
6268                 unsigned int wcap = get_wcaps(codec, 0x04);
6269                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6270                 /* get type */
6271                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6272                         spec->adc_nids = alc260_adc_nids_alt;
6273                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6274                 } else {
6275                         spec->adc_nids = alc260_adc_nids;
6276                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6277                 }
6278         }
6279         set_capture_mixer(spec);
6280         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6281
6282         spec->vmaster_nid = 0x08;
6283
6284         codec->patch_ops = alc_patch_ops;
6285         if (board_config == ALC260_AUTO)
6286                 spec->init_hook = alc260_auto_init;
6287 #ifdef CONFIG_SND_HDA_POWER_SAVE
6288         if (!spec->loopback.amplist)
6289                 spec->loopback.amplist = alc260_loopbacks;
6290 #endif
6291         codec->proc_widget_hook = print_realtek_coef;
6292
6293         return 0;
6294 }
6295
6296
6297 /*
6298  * ALC882/883/885/888/889 support
6299  *
6300  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6301  * configuration.  Each pin widget can choose any input DACs and a mixer.
6302  * Each ADC is connected from a mixer of all inputs.  This makes possible
6303  * 6-channel independent captures.
6304  *
6305  * In addition, an independent DAC for the multi-playback (not used in this
6306  * driver yet).
6307  */
6308 #define ALC882_DIGOUT_NID       0x06
6309 #define ALC882_DIGIN_NID        0x0a
6310 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
6311 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
6312 #define ALC1200_DIGOUT_NID      0x10
6313
6314
6315 static struct hda_channel_mode alc882_ch_modes[1] = {
6316         { 8, NULL }
6317 };
6318
6319 /* DACs */
6320 static hda_nid_t alc882_dac_nids[4] = {
6321         /* front, rear, clfe, rear_surr */
6322         0x02, 0x03, 0x04, 0x05
6323 };
6324 #define alc883_dac_nids         alc882_dac_nids
6325
6326 /* ADCs */
6327 #define alc882_adc_nids         alc880_adc_nids
6328 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6329 #define alc883_adc_nids         alc882_adc_nids_alt
6330 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
6331 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
6332 #define alc889_adc_nids         alc880_adc_nids
6333
6334 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6335 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6336 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
6337 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
6338 #define alc889_capsrc_nids      alc882_capsrc_nids
6339
6340 /* input MUX */
6341 /* FIXME: should be a matrix-type input source selection */
6342
6343 static struct hda_input_mux alc882_capture_source = {
6344         .num_items = 4,
6345         .items = {
6346                 { "Mic", 0x0 },
6347                 { "Front Mic", 0x1 },
6348                 { "Line", 0x2 },
6349                 { "CD", 0x4 },
6350         },
6351 };
6352
6353 #define alc883_capture_source   alc882_capture_source
6354
6355 static struct hda_input_mux alc889_capture_source = {
6356         .num_items = 3,
6357         .items = {
6358                 { "Front Mic", 0x0 },
6359                 { "Mic", 0x3 },
6360                 { "Line", 0x2 },
6361         },
6362 };
6363
6364 static struct hda_input_mux mb5_capture_source = {
6365         .num_items = 3,
6366         .items = {
6367                 { "Mic", 0x1 },
6368                 { "Line", 0x2 },
6369                 { "CD", 0x4 },
6370         },
6371 };
6372
6373 static struct hda_input_mux alc883_3stack_6ch_intel = {
6374         .num_items = 4,
6375         .items = {
6376                 { "Mic", 0x1 },
6377                 { "Front Mic", 0x0 },
6378                 { "Line", 0x2 },
6379                 { "CD", 0x4 },
6380         },
6381 };
6382
6383 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6384         .num_items = 2,
6385         .items = {
6386                 { "Mic", 0x1 },
6387                 { "Line", 0x2 },
6388         },
6389 };
6390
6391 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6392         .num_items = 4,
6393         .items = {
6394                 { "Mic", 0x0 },
6395                 { "iMic", 0x1 },
6396                 { "Line", 0x2 },
6397                 { "CD", 0x4 },
6398         },
6399 };
6400
6401 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6402         .num_items = 2,
6403         .items = {
6404                 { "Mic", 0x0 },
6405                 { "Int Mic", 0x1 },
6406         },
6407 };
6408
6409 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6410         .num_items = 3,
6411         .items = {
6412                 { "Mic", 0x0 },
6413                 { "Front Mic", 0x1 },
6414                 { "Line", 0x4 },
6415         },
6416 };
6417
6418 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6419         .num_items = 2,
6420         .items = {
6421                 { "Mic", 0x0 },
6422                 { "Line", 0x2 },
6423         },
6424 };
6425
6426 static struct hda_input_mux alc889A_mb31_capture_source = {
6427         .num_items = 2,
6428         .items = {
6429                 { "Mic", 0x0 },
6430                 /* Front Mic (0x01) unused */
6431                 { "Line", 0x2 },
6432                 /* Line 2 (0x03) unused */
6433                 /* CD (0x04) unsused? */
6434         },
6435 };
6436
6437 /*
6438  * 2ch mode
6439  */
6440 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6441         { 2, NULL }
6442 };
6443
6444 /*
6445  * 2ch mode
6446  */
6447 static struct hda_verb alc882_3ST_ch2_init[] = {
6448         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6449         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6450         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6451         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6452         { } /* end */
6453 };
6454
6455 /*
6456  * 4ch mode
6457  */
6458 static struct hda_verb alc882_3ST_ch4_init[] = {
6459         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6460         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6461         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6462         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6463         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6464         { } /* end */
6465 };
6466
6467 /*
6468  * 6ch mode
6469  */
6470 static struct hda_verb alc882_3ST_ch6_init[] = {
6471         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6472         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6473         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6474         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6475         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6476         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6477         { } /* end */
6478 };
6479
6480 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
6481         { 2, alc882_3ST_ch2_init },
6482         { 4, alc882_3ST_ch4_init },
6483         { 6, alc882_3ST_ch6_init },
6484 };
6485
6486 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
6487
6488 /*
6489  * 6ch mode
6490  */
6491 static struct hda_verb alc882_sixstack_ch6_init[] = {
6492         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6493         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6494         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6495         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6496         { } /* end */
6497 };
6498
6499 /*
6500  * 8ch mode
6501  */
6502 static struct hda_verb alc882_sixstack_ch8_init[] = {
6503         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6504         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6505         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6506         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6507         { } /* end */
6508 };
6509
6510 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6511         { 6, alc882_sixstack_ch6_init },
6512         { 8, alc882_sixstack_ch8_init },
6513 };
6514
6515 /*
6516  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
6517  */
6518
6519 /*
6520  * 2ch mode
6521  */
6522 static struct hda_verb alc885_mbp_ch2_init[] = {
6523         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6524         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6525         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6526         { } /* end */
6527 };
6528
6529 /*
6530  * 6ch mode
6531  */
6532 static struct hda_verb alc885_mbp_ch6_init[] = {
6533         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6534         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6535         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6536         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6537         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6538         { } /* end */
6539 };
6540
6541 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
6542         { 2, alc885_mbp_ch2_init },
6543         { 6, alc885_mbp_ch6_init },
6544 };
6545
6546 /*
6547  * 2ch
6548  * Speakers/Woofer/HP = Front
6549  * LineIn = Input
6550  */
6551 static struct hda_verb alc885_mb5_ch2_init[] = {
6552         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6553         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6554         { } /* end */
6555 };
6556
6557 /*
6558  * 6ch mode
6559  * Speakers/HP = Front
6560  * Woofer = LFE
6561  * LineIn = Surround
6562  */
6563 static struct hda_verb alc885_mb5_ch6_init[] = {
6564         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6565         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6566         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6567         { } /* end */
6568 };
6569
6570 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
6571         { 2, alc885_mb5_ch2_init },
6572         { 6, alc885_mb5_ch6_init },
6573 };
6574
6575
6576 /*
6577  * 2ch mode
6578  */
6579 static struct hda_verb alc883_4ST_ch2_init[] = {
6580         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6581         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6582         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6583         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6584         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6585         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6586         { } /* end */
6587 };
6588
6589 /*
6590  * 4ch mode
6591  */
6592 static struct hda_verb alc883_4ST_ch4_init[] = {
6593         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6594         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6595         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6596         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6597         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6598         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6599         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6600         { } /* end */
6601 };
6602
6603 /*
6604  * 6ch mode
6605  */
6606 static struct hda_verb alc883_4ST_ch6_init[] = {
6607         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6608         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6609         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6610         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6611         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6612         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6613         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6614         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6615         { } /* end */
6616 };
6617
6618 /*
6619  * 8ch mode
6620  */
6621 static struct hda_verb alc883_4ST_ch8_init[] = {
6622         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6623         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6624         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6625         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6626         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6627         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6628         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6629         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6630         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6631         { } /* end */
6632 };
6633
6634 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
6635         { 2, alc883_4ST_ch2_init },
6636         { 4, alc883_4ST_ch4_init },
6637         { 6, alc883_4ST_ch6_init },
6638         { 8, alc883_4ST_ch8_init },
6639 };
6640
6641
6642 /*
6643  * 2ch mode
6644  */
6645 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
6646         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6647         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6648         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6649         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6650         { } /* end */
6651 };
6652
6653 /*
6654  * 4ch mode
6655  */
6656 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
6657         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6658         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6659         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6660         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6661         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6662         { } /* end */
6663 };
6664
6665 /*
6666  * 6ch mode
6667  */
6668 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
6669         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6670         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6671         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
6672         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6673         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6674         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6675         { } /* end */
6676 };
6677
6678 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
6679         { 2, alc883_3ST_ch2_intel_init },
6680         { 4, alc883_3ST_ch4_intel_init },
6681         { 6, alc883_3ST_ch6_intel_init },
6682 };
6683
6684 /*
6685  * 6ch mode
6686  */
6687 static struct hda_verb alc889_ch6_intel_init[] = {
6688         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6689         { 0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6690         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6691         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6692         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6693         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6694         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6695         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6696         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6697         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6698         { } /* end */
6699 };
6700
6701 /*
6702  * 8ch mode
6703  */
6704 static struct hda_verb alc889_ch8_intel_init[] = {
6705         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6706         { 0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6707         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6708         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6709         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6710         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6711         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6712         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6713         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6714         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6715         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
6716         { } /* end */
6717 };
6718
6719 static struct hda_channel_mode alc889_8ch_intel_modes[2] = {
6720         { 6, alc889_ch6_intel_init },
6721         { 8, alc889_ch8_intel_init },
6722 };
6723
6724 /*
6725  * 6ch mode
6726  */
6727 static struct hda_verb alc883_sixstack_ch6_init[] = {
6728         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6729         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6730         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6731         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6732         { } /* end */
6733 };
6734
6735 /*
6736  * 8ch mode
6737  */
6738 static struct hda_verb alc883_sixstack_ch8_init[] = {
6739         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6740         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6741         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6742         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6743         { } /* end */
6744 };
6745
6746 static struct hda_channel_mode alc883_sixstack_modes[2] = {
6747         { 6, alc883_sixstack_ch6_init },
6748         { 8, alc883_sixstack_ch8_init },
6749 };
6750
6751
6752 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6753  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6754  */
6755 static struct snd_kcontrol_new alc882_base_mixer[] = {
6756         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6757         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6758         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6759         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6760         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6761         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6762         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6763         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6764         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6765         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6766         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6767         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6768         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6769         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6770         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6771         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6772         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6773         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6774         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6775         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6776         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6777         { } /* end */
6778 };
6779
6780 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
6781         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6782         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6783         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
6784         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6785         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6786         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6787         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
6788         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
6789         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
6790         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
6791         { } /* end */
6792 };
6793
6794 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
6795         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6796         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6797         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6798         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
6799         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
6800         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
6801         HDA_CODEC_VOLUME("HP Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
6802         HDA_BIND_MUTE   ("HP Playback Switch", 0x0f, 0x02, HDA_INPUT),
6803         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6804         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6805         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
6806         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
6807         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
6808         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
6809         { } /* end */
6810 };
6811
6812 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
6813         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6814         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6815         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6816         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6817         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6818         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6819         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6820         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6821         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6822         { } /* end */
6823 };
6824
6825 static struct snd_kcontrol_new alc882_targa_mixer[] = {
6826         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6827         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6828         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6829         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6830         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6831         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6832         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6833         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6834         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6835         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6836         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6837         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6838         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6839         { } /* end */
6840 };
6841
6842 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
6843  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
6844  */
6845 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
6846         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6847         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6848         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6849         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
6850         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6851         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6852         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6853         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6854         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
6855         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
6856         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6857         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6858         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6859         { } /* end */
6860 };
6861
6862 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
6863         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6864         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6865         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6866         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6867         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6868         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6869         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6870         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6871         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6872         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6873         { } /* end */
6874 };
6875
6876 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
6877         {
6878                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6879                 .name = "Channel Mode",
6880                 .info = alc_ch_mode_info,
6881                 .get = alc_ch_mode_get,
6882                 .put = alc_ch_mode_put,
6883         },
6884         { } /* end */
6885 };
6886
6887 static struct hda_verb alc882_base_init_verbs[] = {
6888         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6889         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6890         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6891         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6892         /* Rear mixer */
6893         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6894         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6895         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6896         /* CLFE mixer */
6897         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6898         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6899         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6900         /* Side mixer */
6901         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6902         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6903         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6904
6905         /* mute analog input loopbacks */
6906         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6907         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6908         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6909         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6910         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6911
6912         /* Front Pin: output 0 (0x0c) */
6913         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6914         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6915         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6916         /* Rear Pin: output 1 (0x0d) */
6917         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6918         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6919         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6920         /* CLFE Pin: output 2 (0x0e) */
6921         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6922         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6923         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
6924         /* Side Pin: output 3 (0x0f) */
6925         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6926         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6927         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
6928         /* Mic (rear) pin: input vref at 80% */
6929         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6930         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6931         /* Front Mic pin: input vref at 80% */
6932         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6933         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6934         /* Line In pin: input */
6935         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6936         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6937         /* Line-2 In: Headphone output (output 0 - 0x0c) */
6938         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6939         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6940         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
6941         /* CD pin widget for input */
6942         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6943
6944         /* FIXME: use matrix-type input source selection */
6945         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6946         /* Input mixer2 */
6947         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6948         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6949         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6950         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6951         /* Input mixer3 */
6952         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6953         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6954         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6955         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6956         /* ADC2: mute amp left and right */
6957         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6958         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6959         /* ADC3: mute amp left and right */
6960         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6961         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6962
6963         { }
6964 };
6965
6966 static struct hda_verb alc882_adc1_init_verbs[] = {
6967         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6968         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6969         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6970         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6971         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6972         /* ADC1: mute amp left and right */
6973         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6974         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6975         { }
6976 };
6977
6978 static struct hda_verb alc882_eapd_verbs[] = {
6979         /* change to EAPD mode */
6980         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6981         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
6982         { }
6983 };
6984
6985 static struct hda_verb alc889_eapd_verbs[] = {
6986         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
6987         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
6988         { }
6989 };
6990
6991
6992 static struct hda_verb alc885_init_verbs[] = {
6993         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6994         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6995         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6996         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6997         /* Rear mixer */
6998         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6999         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7000         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7001         /* CLFE mixer */
7002         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7003         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7004         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7005         /* Side mixer */
7006         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7007         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7008         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7009
7010         /* mute analog input loopbacks */
7011         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7012         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7013         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7014
7015         /* Front HP Pin: output 0 (0x0c) */
7016         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7017         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7018         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7019         /* Front Pin: output 0 (0x0c) */
7020         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7021         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7022         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7023         /* Rear Pin: output 1 (0x0d) */
7024         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7025         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7026         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
7027         /* CLFE Pin: output 2 (0x0e) */
7028         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7029         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7030         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7031         /* Side Pin: output 3 (0x0f) */
7032         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7033         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7034         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7035         /* Mic (rear) pin: input vref at 80% */
7036         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7037         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7038         /* Front Mic pin: input vref at 80% */
7039         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7040         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7041         /* Line In pin: input */
7042         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7043         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7044
7045         /* Mixer elements: 0x18, , 0x1a, 0x1b */
7046         /* Input mixer1 */
7047         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7048         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7049         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7050         /* Input mixer2 */
7051         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7052         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7053         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7054         /* Input mixer3 */
7055         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7056         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7057         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7058         /* ADC2: mute amp left and right */
7059         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7060         /* ADC3: mute amp left and right */
7061         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7062
7063         { }
7064 };
7065
7066 static struct hda_verb alc885_init_input_verbs[] = {
7067         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7068         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7069         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7070         { }
7071 };
7072
7073
7074 /* Unmute Selector 24h and set the default input to front mic */
7075 static struct hda_verb alc889_init_input_verbs[] = {
7076         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
7077         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7078         { }
7079 };
7080
7081
7082 #define alc883_init_verbs       alc882_base_init_verbs
7083
7084 /* Mac Pro test */
7085 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
7086         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7087         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7088         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
7089         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
7090         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
7091         /* FIXME: this looks suspicious...
7092         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
7093         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
7094         */
7095         { } /* end */
7096 };
7097
7098 static struct hda_verb alc882_macpro_init_verbs[] = {
7099         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7100         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7101         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7102         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7103         /* Front Pin: output 0 (0x0c) */
7104         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7105         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7106         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7107         /* Front Mic pin: input vref at 80% */
7108         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7109         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7110         /* Speaker:  output */
7111         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7112         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7113         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
7114         /* Headphone output (output 0 - 0x0c) */
7115         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7116         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7117         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7118
7119         /* FIXME: use matrix-type input source selection */
7120         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7121         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7122         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7123         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7124         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7125         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7126         /* Input mixer2 */
7127         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7128         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7129         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7130         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7131         /* Input mixer3 */
7132         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7133         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7134         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7135         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7136         /* ADC1: mute amp left and right */
7137         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7138         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7139         /* ADC2: mute amp left and right */
7140         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7141         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7142         /* ADC3: mute amp left and right */
7143         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7144         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7145
7146         { }
7147 };
7148
7149 /* Macbook 5,1 */
7150 static struct hda_verb alc885_mb5_init_verbs[] = {
7151         /* DACs */
7152         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7153         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7154         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7155         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7156         /* Front mixer */
7157         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7158         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7159         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7160         /* Surround mixer */
7161         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7162         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7163         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7164         /* LFE mixer */
7165         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7166         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7167         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7168         /* HP mixer */
7169         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7170         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7171         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7172         /* Front Pin (0x0c) */
7173         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7174         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7175         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7176         /* LFE Pin (0x0e) */
7177         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7178         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7179         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7180         /* HP Pin (0x0f) */
7181         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7182         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7183         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7184         /* Front Mic pin: input vref at 80% */
7185         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7186         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7187         /* Line In pin */
7188         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7189         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7190
7191         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7192         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7193         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7194         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7195         { }
7196 };
7197
7198 /* Macbook Pro rev3 */
7199 static struct hda_verb alc885_mbp3_init_verbs[] = {
7200         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7201         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7202         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7203         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7204         /* Rear mixer */
7205         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7206         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7207         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7208         /* Front Pin: output 0 (0x0c) */
7209         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7210         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7211         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7212         /* HP Pin: output 0 (0x0d) */
7213         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7214         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7215         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7216         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7217         /* Mic (rear) pin: input vref at 80% */
7218         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7219         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7220         /* Front Mic pin: input vref at 80% */
7221         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7222         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7223         /* Line In pin: use output 1 when in LineOut mode */
7224         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7225         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7226         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7227
7228         /* FIXME: use matrix-type input source selection */
7229         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7230         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7231         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7232         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7233         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7234         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7235         /* Input mixer2 */
7236         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7237         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7238         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7239         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7240         /* Input mixer3 */
7241         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7242         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7243         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7244         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7245         /* ADC1: mute amp left and right */
7246         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7247         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7248         /* ADC2: mute amp left and right */
7249         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7250         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7251         /* ADC3: mute amp left and right */
7252         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7253         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7254
7255         { }
7256 };
7257
7258 /* iMac 24 mixer. */
7259 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
7260         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7261         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
7262         { } /* end */
7263 };
7264
7265 /* iMac 24 init verbs. */
7266 static struct hda_verb alc885_imac24_init_verbs[] = {
7267         /* Internal speakers: output 0 (0x0c) */
7268         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7269         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7270         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7271         /* Internal speakers: output 0 (0x0c) */
7272         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7273         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7274         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7275         /* Headphone: output 0 (0x0c) */
7276         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7277         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7278         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7279         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7280         /* Front Mic: input vref at 80% */
7281         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7282         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7283         { }
7284 };
7285
7286 /* Toggle speaker-output according to the hp-jack state */
7287 static void alc885_imac24_automute_init_hook(struct hda_codec *codec)
7288 {
7289         struct alc_spec *spec = codec->spec;
7290
7291         spec->autocfg.hp_pins[0] = 0x14;
7292         spec->autocfg.speaker_pins[0] = 0x18;
7293         spec->autocfg.speaker_pins[1] = 0x1a;
7294         alc_automute_amp(codec);
7295 }
7296
7297 static void alc885_mbp3_init_hook(struct hda_codec *codec)
7298 {
7299         struct alc_spec *spec = codec->spec;
7300
7301         spec->autocfg.hp_pins[0] = 0x15;
7302         spec->autocfg.speaker_pins[0] = 0x14;
7303         alc_automute_amp(codec);
7304 }
7305
7306
7307 static struct hda_verb alc882_targa_verbs[] = {
7308         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7309         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7310
7311         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7312         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7313
7314         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7315         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7316         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7317
7318         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7319         { } /* end */
7320 };
7321
7322 /* toggle speaker-output according to the hp-jack state */
7323 static void alc882_targa_automute(struct hda_codec *codec)
7324 {
7325         struct alc_spec *spec = codec->spec;
7326         alc_automute_amp(codec);
7327         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7328                                   spec->jack_present ? 1 : 3);
7329 }
7330
7331 static void alc882_targa_init_hook(struct hda_codec *codec)
7332 {
7333         struct alc_spec *spec = codec->spec;
7334
7335         spec->autocfg.hp_pins[0] = 0x14;
7336         spec->autocfg.speaker_pins[0] = 0x1b;
7337         alc882_targa_automute(codec);
7338 }
7339
7340 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
7341 {
7342         if ((res >> 26) == ALC880_HP_EVENT)
7343                 alc882_targa_automute(codec);
7344 }
7345
7346 static struct hda_verb alc882_asus_a7j_verbs[] = {
7347         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7348         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7349
7350         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7351         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7352         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7353
7354         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7355         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7356         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7357
7358         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7359         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7360         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7361         { } /* end */
7362 };
7363
7364 static struct hda_verb alc882_asus_a7m_verbs[] = {
7365         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7366         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7367
7368         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7369         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7370         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7371
7372         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7373         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7374         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7375
7376         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7377         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7378         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7379         { } /* end */
7380 };
7381
7382 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
7383 {
7384         unsigned int gpiostate, gpiomask, gpiodir;
7385
7386         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
7387                                        AC_VERB_GET_GPIO_DATA, 0);
7388
7389         if (!muted)
7390                 gpiostate |= (1 << pin);
7391         else
7392                 gpiostate &= ~(1 << pin);
7393
7394         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
7395                                       AC_VERB_GET_GPIO_MASK, 0);
7396         gpiomask |= (1 << pin);
7397
7398         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
7399                                      AC_VERB_GET_GPIO_DIRECTION, 0);
7400         gpiodir |= (1 << pin);
7401
7402
7403         snd_hda_codec_write(codec, codec->afg, 0,
7404                             AC_VERB_SET_GPIO_MASK, gpiomask);
7405         snd_hda_codec_write(codec, codec->afg, 0,
7406                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
7407
7408         msleep(1);
7409
7410         snd_hda_codec_write(codec, codec->afg, 0,
7411                             AC_VERB_SET_GPIO_DATA, gpiostate);
7412 }
7413
7414 /* set up GPIO at initialization */
7415 static void alc885_macpro_init_hook(struct hda_codec *codec)
7416 {
7417         alc882_gpio_mute(codec, 0, 0);
7418         alc882_gpio_mute(codec, 1, 0);
7419 }
7420
7421 /* set up GPIO and update auto-muting at initialization */
7422 static void alc885_imac24_init_hook(struct hda_codec *codec)
7423 {
7424         alc885_macpro_init_hook(codec);
7425         alc885_imac24_automute_init_hook(codec);
7426 }
7427
7428 /*
7429  * generic initialization of ADC, input mixers and output mixers
7430  */
7431 static struct hda_verb alc883_auto_init_verbs[] = {
7432         /*
7433          * Unmute ADC0-2 and set the default input to mic-in
7434          */
7435         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7436         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7437         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7438         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7439
7440         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7441          * mixer widget
7442          * Note: PASD motherboards uses the Line In 2 as the input for
7443          * front panel mic (mic 2)
7444          */
7445         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7446         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7447         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7448         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7449         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7450         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7451
7452         /*
7453          * Set up output mixers (0x0c - 0x0f)
7454          */
7455         /* set vol=0 to output mixers */
7456         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7457         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7458         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7459         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7460         /* set up input amps for analog loopback */
7461         /* Amp Indices: DAC = 0, mixer = 1 */
7462         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7463         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7464         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7465         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7466         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7467         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7468         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7469         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7470         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7471         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7472
7473         /* FIXME: use matrix-type input source selection */
7474         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7475         /* Input mixer2 */
7476         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7477         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7478         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7479         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7480         /* Input mixer3 */
7481         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7482         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7483         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7484         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7485
7486         { }
7487 };
7488
7489 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
7490 static struct hda_verb alc889A_mb31_ch2_init[] = {
7491         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7492         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7493         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7494         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7495         { } /* end */
7496 };
7497
7498 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
7499 static struct hda_verb alc889A_mb31_ch4_init[] = {
7500         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7501         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7502         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7503         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7504         { } /* end */
7505 };
7506
7507 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
7508 static struct hda_verb alc889A_mb31_ch5_init[] = {
7509         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
7510         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7511         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7512         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7513         { } /* end */
7514 };
7515
7516 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
7517 static struct hda_verb alc889A_mb31_ch6_init[] = {
7518         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
7519         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
7520         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7521         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7522         { } /* end */
7523 };
7524
7525 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
7526         { 2, alc889A_mb31_ch2_init },
7527         { 4, alc889A_mb31_ch4_init },
7528         { 5, alc889A_mb31_ch5_init },
7529         { 6, alc889A_mb31_ch6_init },
7530 };
7531
7532 static struct hda_verb alc883_medion_eapd_verbs[] = {
7533         /* eanable EAPD on medion laptop */
7534         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7535         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7536         { }
7537 };
7538
7539 #define alc883_base_mixer       alc882_base_mixer
7540
7541 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7542         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7543         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7544         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7545         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7546         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7547         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7548         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7549         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7550         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7551         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7552         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7553         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7554         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7555         { } /* end */
7556 };
7557
7558 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7559         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7560         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7561         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7562         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7563         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7564         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7565         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7566         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7567         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7568         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7569         { } /* end */
7570 };
7571
7572 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7573         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7574         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7575         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7576         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7577         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7578         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7579         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7580         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7581         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7582         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7583         { } /* end */
7584 };
7585
7586 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7587         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7588         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7589         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7590         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7591         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7592         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7593         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7594         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7595         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7596         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7597         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7598         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7599         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7600         { } /* end */
7601 };
7602
7603 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7604         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7605         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7606         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7607         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7608         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7609         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7610         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7611         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7612         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7613         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7614         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7615         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7616         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7617         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7618         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7619         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7620         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7621         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7622         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7623         { } /* end */
7624 };
7625
7626 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7627         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7628         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7629         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7630         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7631         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7632                               HDA_OUTPUT),
7633         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7634         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7635         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7636         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7637         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7638         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7639         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7640         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7641         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7642         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7643         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7644         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7645         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7646         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7647         { } /* end */
7648 };
7649
7650 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
7651         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7652         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7653         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7654         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7655         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7656                               HDA_OUTPUT),
7657         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7658         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7659         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7660         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7661         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
7662         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7663         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7664         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7665         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
7666         HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
7667         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
7668         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7669         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7670         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7671         { } /* end */
7672 };
7673
7674 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7675         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7676         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7677         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7678         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7679         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7680         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7681         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7682         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7683         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7684         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7685         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7686         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7687         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7688         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7689         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7690         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7691         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7692         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7693         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7694         { } /* end */
7695 };
7696
7697 static struct snd_kcontrol_new alc883_targa_mixer[] = {
7698         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7699         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7700         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7701         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7702         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7703         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7704         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7705         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7706         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7707         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7708         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7709         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7710         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7711         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7712         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7713         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7714         { } /* end */
7715 };
7716
7717 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
7718         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7719         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7720         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7721         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7722         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7723         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7724         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7725         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7726         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7727         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7728         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7729         { } /* end */
7730 };
7731
7732 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7733         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7734         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7735         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7736         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7737         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7738         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7739         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7740         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7741         { } /* end */
7742 };
7743
7744 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7745         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7746         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7747         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7748         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7749         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7750         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7751         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7752         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7753         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7754         { } /* end */
7755 };
7756
7757 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7758         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7759         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7760         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7761         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7762         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7763         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7764         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7765         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7766         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7767         { } /* end */
7768 };
7769
7770 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7771         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7772         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7773         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7774         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7775         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7776         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7777         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7778         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7779         { } /* end */
7780 };
7781
7782 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
7783         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7784         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7785         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7786         HDA_BIND_MUTE("LFE Playback Switch", 0x0f, 2, HDA_INPUT),
7787         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7788         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7789         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7790         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7791         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7792         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7793         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7794         { } /* end */
7795 };
7796
7797 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7798         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7799         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7800         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7801         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7802         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7803                                                 0x0d, 1, 0x0, HDA_OUTPUT),
7804         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7805         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7806         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7807         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7808         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7809         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7810         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7811         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7812         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7813         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7814         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7815         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7816         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7817         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7818         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7819         { } /* end */
7820 };
7821
7822 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
7823         /* Output mixers */
7824         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7825         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7826         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7827         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7828         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
7829                 HDA_OUTPUT),
7830         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
7831         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
7832         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
7833         /* Output switches */
7834         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
7835         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
7836         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
7837         /* Boost mixers */
7838         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7839         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7840         /* Input mixers */
7841         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7842         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7843         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7844         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7845         { } /* end */
7846 };
7847
7848 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
7849         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7850         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7851         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7852         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7853         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7854         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7855         { } /* end */
7856 };
7857
7858 static struct hda_bind_ctls alc883_bind_cap_vol = {
7859         .ops = &snd_hda_bind_vol,
7860         .values = {
7861                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7862                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7863                 0
7864         },
7865 };
7866
7867 static struct hda_bind_ctls alc883_bind_cap_switch = {
7868         .ops = &snd_hda_bind_sw,
7869         .values = {
7870                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7871                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7872                 0
7873         },
7874 };
7875
7876 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
7877         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7878         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7879         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7880         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7881         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7882         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7883         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7884         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7885         { } /* end */
7886 };
7887
7888 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
7889         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
7890         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
7891         {
7892                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7893                 /* .name = "Capture Source", */
7894                 .name = "Input Source",
7895                 .count = 1,
7896                 .info = alc_mux_enum_info,
7897                 .get = alc_mux_enum_get,
7898                 .put = alc_mux_enum_put,
7899         },
7900         { } /* end */
7901 };
7902
7903 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7904         {
7905                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7906                 .name = "Channel Mode",
7907                 .info = alc_ch_mode_info,
7908                 .get = alc_ch_mode_get,
7909                 .put = alc_ch_mode_put,
7910         },
7911         { } /* end */
7912 };
7913
7914 /* toggle speaker-output according to the hp-jack state */
7915 static void alc883_mitac_init_hook(struct hda_codec *codec)
7916 {
7917         struct alc_spec *spec = codec->spec;
7918
7919         spec->autocfg.hp_pins[0] = 0x15;
7920         spec->autocfg.speaker_pins[0] = 0x14;
7921         spec->autocfg.speaker_pins[1] = 0x17;
7922         alc_automute_amp(codec);
7923 }
7924
7925 /* auto-toggle front mic */
7926 /*
7927 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7928 {
7929         unsigned int present;
7930         unsigned char bits;
7931
7932         present = snd_hda_codec_read(codec, 0x18, 0,
7933                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7934         bits = present ? HDA_AMP_MUTE : 0;
7935         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7936 }
7937 */
7938
7939 static struct hda_verb alc883_mitac_verbs[] = {
7940         /* HP */
7941         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7942         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7943         /* Subwoofer */
7944         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7945         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7946
7947         /* enable unsolicited event */
7948         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7949         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7950
7951         { } /* end */
7952 };
7953
7954 static struct hda_verb alc883_clevo_m720_verbs[] = {
7955         /* HP */
7956         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7957         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7958         /* Int speaker */
7959         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
7960         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7961
7962         /* enable unsolicited event */
7963         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7964         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
7965
7966         { } /* end */
7967 };
7968
7969 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
7970         /* HP */
7971         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7972         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7973         /* Subwoofer */
7974         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7975         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7976
7977         /* enable unsolicited event */
7978         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7979
7980         { } /* end */
7981 };
7982
7983 static struct hda_verb alc883_targa_verbs[] = {
7984         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7985         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7986
7987         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7988         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7989
7990 /* Connect Line-Out side jack (SPDIF) to Side */
7991         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7992         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7993         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7994 /* Connect Mic jack to CLFE */
7995         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7996         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7997         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
7998 /* Connect Line-in jack to Surround */
7999         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8000         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8001         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8002 /* Connect HP out jack to Front */
8003         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8004         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8005         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8006
8007         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8008
8009         { } /* end */
8010 };
8011
8012 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8013         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8014         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8015         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8016         { } /* end */
8017 };
8018
8019 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8020         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8021         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8022         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8023         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8024         { } /* end */
8025 };
8026
8027 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8028         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8029         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8030         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8031         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8032         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8033         { } /* end */
8034 };
8035
8036 static struct hda_verb alc883_haier_w66_verbs[] = {
8037         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8038         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8039
8040         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8041
8042         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8043         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8044         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8045         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8046         { } /* end */
8047 };
8048
8049 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8050         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8051         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8052         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8053         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8054         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8055         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8056         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8057         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8058         { } /* end */
8059 };
8060
8061 static struct hda_verb alc888_6st_dell_verbs[] = {
8062         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8063         { }
8064 };
8065
8066 static struct hda_verb alc883_vaiott_verbs[] = {
8067         /* HP */
8068         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8069         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8070
8071         /* enable unsolicited event */
8072         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8073
8074         { } /* end */
8075 };
8076
8077 static void alc888_3st_hp_init_hook(struct hda_codec *codec)
8078 {
8079         struct alc_spec *spec = codec->spec;
8080
8081         spec->autocfg.hp_pins[0] = 0x1b;
8082         spec->autocfg.speaker_pins[0] = 0x14;
8083         spec->autocfg.speaker_pins[1] = 0x16;
8084         spec->autocfg.speaker_pins[2] = 0x18;
8085         alc_automute_amp(codec);
8086 }
8087
8088 static struct hda_verb alc888_3st_hp_verbs[] = {
8089         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8090         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8091         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8092         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8093         { } /* end */
8094 };
8095
8096 /*
8097  * 2ch mode
8098  */
8099 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8100         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8101         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8102         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8103         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8104         { } /* end */
8105 };
8106
8107 /*
8108  * 4ch mode
8109  */
8110 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8111         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8112         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8113         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8114         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8115         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8116         { } /* end */
8117 };
8118
8119 /*
8120  * 6ch mode
8121  */
8122 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8123         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8124         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8125         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8126         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8127         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8128         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8129         { } /* end */
8130 };
8131
8132 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8133         { 2, alc888_3st_hp_2ch_init },
8134         { 4, alc888_3st_hp_4ch_init },
8135         { 6, alc888_3st_hp_6ch_init },
8136 };
8137
8138 /* toggle front-jack and RCA according to the hp-jack state */
8139 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8140 {
8141         unsigned int present;
8142
8143         present = snd_hda_codec_read(codec, 0x1b, 0,
8144                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8145         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8146                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8147         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8148                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8149 }
8150
8151 /* toggle RCA according to the front-jack state */
8152 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8153 {
8154         unsigned int present;
8155
8156         present = snd_hda_codec_read(codec, 0x14, 0,
8157                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8158         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8159                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8160 }
8161
8162 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8163                                              unsigned int res)
8164 {
8165         if ((res >> 26) == ALC880_HP_EVENT)
8166                 alc888_lenovo_ms7195_front_automute(codec);
8167         if ((res >> 26) == ALC880_FRONT_EVENT)
8168                 alc888_lenovo_ms7195_rca_automute(codec);
8169 }
8170
8171 static struct hda_verb alc883_medion_md2_verbs[] = {
8172         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8173         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8174
8175         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8176
8177         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8178         { } /* end */
8179 };
8180
8181 /* toggle speaker-output according to the hp-jack state */
8182 static void alc883_medion_md2_init_hook(struct hda_codec *codec)
8183 {
8184         struct alc_spec *spec = codec->spec;
8185
8186         spec->autocfg.hp_pins[0] = 0x14;
8187         spec->autocfg.speaker_pins[0] = 0x15;
8188         alc_automute_amp(codec);
8189 }
8190
8191 /* toggle speaker-output according to the hp-jack state */
8192 #define alc883_targa_init_hook          alc882_targa_init_hook
8193 #define alc883_targa_unsol_event        alc882_targa_unsol_event
8194
8195 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8196 {
8197         unsigned int present;
8198
8199         present = snd_hda_codec_read(codec, 0x18, 0,
8200                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8201         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8202                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8203 }
8204
8205 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8206 {
8207         struct alc_spec *spec = codec->spec;
8208
8209         spec->autocfg.hp_pins[0] = 0x15;
8210         spec->autocfg.speaker_pins[0] = 0x14;
8211         alc_automute_amp(codec);
8212         alc883_clevo_m720_mic_automute(codec);
8213 }
8214
8215 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8216                                            unsigned int res)
8217 {
8218         switch (res >> 26) {
8219         case ALC880_MIC_EVENT:
8220                 alc883_clevo_m720_mic_automute(codec);
8221                 break;
8222         default:
8223                 alc_automute_amp_unsol_event(codec, res);
8224                 break;
8225         }
8226 }
8227
8228 /* toggle speaker-output according to the hp-jack state */
8229 static void alc883_2ch_fujitsu_pi2515_init_hook(struct hda_codec *codec)
8230 {
8231         struct alc_spec *spec = codec->spec;
8232
8233         spec->autocfg.hp_pins[0] = 0x14;
8234         spec->autocfg.speaker_pins[0] = 0x15;
8235         alc_automute_amp(codec);
8236 }
8237
8238 static void alc883_haier_w66_init_hook(struct hda_codec *codec)
8239 {
8240         struct alc_spec *spec = codec->spec;
8241
8242         spec->autocfg.hp_pins[0] = 0x1b;
8243         spec->autocfg.speaker_pins[0] = 0x14;
8244         alc_automute_amp(codec);
8245 }
8246
8247 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8248 {
8249         unsigned int present;
8250         unsigned char bits;
8251
8252         present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
8253                 & AC_PINSENSE_PRESENCE;
8254         bits = present ? HDA_AMP_MUTE : 0;
8255         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8256                                  HDA_AMP_MUTE, bits);
8257 }
8258
8259 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8260 {
8261         unsigned int present;
8262         unsigned char bits;
8263
8264         present = snd_hda_codec_read(codec, 0x1b, 0,
8265                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8266         bits = present ? HDA_AMP_MUTE : 0;
8267         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8268                                  HDA_AMP_MUTE, bits);
8269         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8270                                  HDA_AMP_MUTE, bits);
8271 }
8272
8273 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8274                                            unsigned int res)
8275 {
8276         if ((res >> 26) == ALC880_HP_EVENT)
8277                 alc883_lenovo_101e_all_automute(codec);
8278         if ((res >> 26) == ALC880_FRONT_EVENT)
8279                 alc883_lenovo_101e_ispeaker_automute(codec);
8280 }
8281
8282 /* toggle speaker-output according to the hp-jack state */
8283 static void alc883_acer_aspire_init_hook(struct hda_codec *codec)
8284 {
8285         struct alc_spec *spec = codec->spec;
8286
8287         spec->autocfg.hp_pins[0] = 0x14;
8288         spec->autocfg.speaker_pins[0] = 0x15;
8289         spec->autocfg.speaker_pins[1] = 0x16;
8290         alc_automute_amp(codec);
8291 }
8292
8293 static struct hda_verb alc883_acer_eapd_verbs[] = {
8294         /* HP Pin: output 0 (0x0c) */
8295         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8296         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8297         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8298         /* Front Pin: output 0 (0x0c) */
8299         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8300         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8301         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8302         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8303         /* eanable EAPD on medion laptop */
8304         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8305         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8306         /* enable unsolicited event */
8307         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8308         { }
8309 };
8310
8311 static void alc888_6st_dell_init_hook(struct hda_codec *codec)
8312 {
8313         struct alc_spec *spec = codec->spec;
8314
8315         spec->autocfg.hp_pins[0] = 0x1b;
8316         spec->autocfg.speaker_pins[0] = 0x14;
8317         spec->autocfg.speaker_pins[1] = 0x15;
8318         spec->autocfg.speaker_pins[2] = 0x16;
8319         spec->autocfg.speaker_pins[3] = 0x17;
8320         alc_automute_amp(codec);
8321 }
8322
8323 static void alc888_lenovo_sky_init_hook(struct hda_codec *codec)
8324 {
8325         struct alc_spec *spec = codec->spec;
8326
8327         spec->autocfg.hp_pins[0] = 0x1b;
8328         spec->autocfg.speaker_pins[0] = 0x14;
8329         spec->autocfg.speaker_pins[1] = 0x15;
8330         spec->autocfg.speaker_pins[2] = 0x16;
8331         spec->autocfg.speaker_pins[3] = 0x17;
8332         spec->autocfg.speaker_pins[4] = 0x1a;
8333         alc_automute_amp(codec);
8334 }
8335
8336 static void alc883_vaiott_init_hook(struct hda_codec *codec)
8337 {
8338         struct alc_spec *spec = codec->spec;
8339
8340         spec->autocfg.hp_pins[0] = 0x15;
8341         spec->autocfg.speaker_pins[0] = 0x14;
8342         spec->autocfg.speaker_pins[1] = 0x17;
8343         alc_automute_amp(codec);
8344 }
8345
8346 static struct hda_verb alc888_asus_m90v_verbs[] = {
8347         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8348         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8349         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8350         /* enable unsolicited event */
8351         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8352         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8353         { } /* end */
8354 };
8355
8356 static void alc883_nb_mic_automute(struct hda_codec *codec)
8357 {
8358         unsigned int present;
8359
8360         present = snd_hda_codec_read(codec, 0x18, 0,
8361                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8362         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8363                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8364         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8365                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8366 }
8367
8368 static void alc883_M90V_init_hook(struct hda_codec *codec)
8369 {
8370         struct alc_spec *spec = codec->spec;
8371
8372         spec->autocfg.hp_pins[0] = 0x1b;
8373         spec->autocfg.speaker_pins[0] = 0x14;
8374         spec->autocfg.speaker_pins[1] = 0x15;
8375         spec->autocfg.speaker_pins[2] = 0x16;
8376         alc_automute_pin(codec);
8377 }
8378
8379 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8380                                            unsigned int res)
8381 {
8382         switch (res >> 26) {
8383         case ALC880_MIC_EVENT:
8384                 alc883_nb_mic_automute(codec);
8385                 break;
8386         default:
8387                 alc_sku_unsol_event(codec, res);
8388                 break;
8389         }
8390 }
8391
8392 static void alc883_mode2_inithook(struct hda_codec *codec)
8393 {
8394         alc883_M90V_init_hook(codec);
8395         alc883_nb_mic_automute(codec);
8396 }
8397
8398 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8399         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8400         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8401         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8402         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8403         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8404         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8405         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8406         /* enable unsolicited event */
8407         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8408         { } /* end */
8409 };
8410
8411 static void alc883_eee1601_inithook(struct hda_codec *codec)
8412 {
8413         struct alc_spec *spec = codec->spec;
8414
8415         spec->autocfg.hp_pins[0] = 0x14;
8416         spec->autocfg.speaker_pins[0] = 0x1b;
8417         alc_automute_pin(codec);
8418 }
8419
8420 static struct hda_verb alc889A_mb31_verbs[] = {
8421         /* Init rear pin (used as headphone output) */
8422         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
8423         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
8424         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8425         /* Init line pin (used as output in 4ch and 6ch mode) */
8426         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
8427         /* Init line 2 pin (used as headphone out by default) */
8428         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
8429         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
8430         { } /* end */
8431 };
8432
8433 /* Mute speakers according to the headphone jack state */
8434 static void alc889A_mb31_automute(struct hda_codec *codec)
8435 {
8436         unsigned int present;
8437
8438         /* Mute only in 2ch or 4ch mode */
8439         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
8440             == 0x00) {
8441                 present = snd_hda_codec_read(codec, 0x15, 0,
8442                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
8443                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
8444                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8445                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8446                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8447         }
8448 }
8449
8450 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
8451 {
8452         if ((res >> 26) == ALC880_HP_EVENT)
8453                 alc889A_mb31_automute(codec);
8454 }
8455
8456
8457 #ifdef CONFIG_SND_HDA_POWER_SAVE
8458 #define alc882_loopbacks        alc880_loopbacks
8459 #endif
8460
8461 /* pcm configuration: identical with ALC880 */
8462 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
8463 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
8464 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
8465 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
8466
8467 static hda_nid_t alc883_slave_dig_outs[] = {
8468         ALC1200_DIGOUT_NID, 0,
8469 };
8470
8471 static hda_nid_t alc1200_slave_dig_outs[] = {
8472         ALC883_DIGOUT_NID, 0,
8473 };
8474
8475 /*
8476  * configuration and preset
8477  */
8478 static const char *alc882_models[ALC882_MODEL_LAST] = {
8479         [ALC882_3ST_DIG]        = "3stack-dig",
8480         [ALC882_6ST_DIG]        = "6stack-dig",
8481         [ALC882_ARIMA]          = "arima",
8482         [ALC882_W2JC]           = "w2jc",
8483         [ALC882_TARGA]          = "targa",
8484         [ALC882_ASUS_A7J]       = "asus-a7j",
8485         [ALC882_ASUS_A7M]       = "asus-a7m",
8486         [ALC885_MACPRO]         = "macpro",
8487         [ALC885_MB5]            = "mb5",
8488         [ALC885_MBP3]           = "mbp3",
8489         [ALC885_IMAC24]         = "imac24",
8490         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
8491         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8492         [ALC883_3ST_6ch]        = "3stack-6ch",
8493         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
8494         [ALC883_TARGA_DIG]      = "targa-dig",
8495         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8496         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
8497         [ALC883_ACER]           = "acer",
8498         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8499         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8500         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
8501         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
8502         [ALC883_MEDION]         = "medion",
8503         [ALC883_MEDION_MD2]     = "medion-md2",
8504         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8505         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8506         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8507         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8508         [ALC888_LENOVO_SKY] = "lenovo-sky",
8509         [ALC883_HAIER_W66]      = "haier-w66",
8510         [ALC888_3ST_HP]         = "3stack-hp",
8511         [ALC888_6ST_DELL]       = "6stack-dell",
8512         [ALC883_MITAC]          = "mitac",
8513         [ALC883_CLEVO_M720]     = "clevo-m720",
8514         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8515         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8516         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8517         [ALC889A_INTEL]         = "intel-alc889a",
8518         [ALC889_INTEL]          = "intel-x58",
8519         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8520         [ALC889A_MB31]          = "mb31",
8521         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
8522         [ALC882_AUTO]           = "auto",
8523 };
8524
8525 static struct snd_pci_quirk alc882_cfg_tbl[] = {
8526         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
8527
8528         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8529         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8530         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
8531         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8532         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8533         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8534         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8535                 ALC888_ACER_ASPIRE_4930G),
8536         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8537                 ALC888_ACER_ASPIRE_4930G),
8538         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
8539                 ALC888_ACER_ASPIRE_8930G),
8540         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
8541                 ALC888_ACER_ASPIRE_8930G),
8542         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
8543         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
8544         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8545                 ALC888_ACER_ASPIRE_6530G),
8546         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8547                 ALC888_ACER_ASPIRE_6530G),
8548         /* default Acer -- disabled as it causes more problems.
8549          *    model=auto should work fine now
8550          */
8551         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
8552
8553         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8554
8555         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8556         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8557         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8558         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8559         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8560         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
8561
8562         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
8563         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
8564         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
8565         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8566         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
8567         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
8568         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
8569         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8570         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8571         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8572         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8573
8574         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
8575         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8576         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
8577         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8578         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8579         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8580         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8581         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8582         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
8583
8584         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8585         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8586         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8587         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
8588         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8589         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
8590         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8591         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8592         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8593         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8594         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8595         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8596         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8597         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8598         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
8599         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8600         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8601         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8602         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
8603         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8604         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8605         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8606         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8607         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8608         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8609         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8610         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
8611         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8612         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
8613
8614         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8615         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8616         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8617         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
8618         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8619         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
8620         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8621         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
8622                       ALC883_FUJITSU_PI2515),
8623         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
8624                 ALC888_FUJITSU_XA3530),
8625         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8626         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8627         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8628         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8629         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8630         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8631         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
8632         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8633         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8634
8635         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8636         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8637         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
8638         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
8639         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
8640         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
8641         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8642
8643         {}
8644 };
8645
8646 /* codec SSID table for Intel Mac */
8647 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
8648         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
8649         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
8650         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
8651         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
8652         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
8653         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
8654         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
8655         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
8656         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
8657         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
8658         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
8659         /* FIXME: HP jack sense seems not working for MBP 5,1, so apparently
8660          * no perfect solution yet
8661          */
8662         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
8663         {} /* terminator */
8664 };
8665
8666 static struct alc_config_preset alc882_presets[] = {
8667         [ALC882_3ST_DIG] = {
8668                 .mixers = { alc882_base_mixer },
8669                 .init_verbs = { alc882_base_init_verbs,
8670                                 alc882_adc1_init_verbs },
8671                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8672                 .dac_nids = alc882_dac_nids,
8673                 .dig_out_nid = ALC882_DIGOUT_NID,
8674                 .dig_in_nid = ALC882_DIGIN_NID,
8675                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
8676                 .channel_mode = alc882_ch_modes,
8677                 .need_dac_fix = 1,
8678                 .input_mux = &alc882_capture_source,
8679         },
8680         [ALC882_6ST_DIG] = {
8681                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
8682                 .init_verbs = { alc882_base_init_verbs,
8683                                 alc882_adc1_init_verbs },
8684                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8685                 .dac_nids = alc882_dac_nids,
8686                 .dig_out_nid = ALC882_DIGOUT_NID,
8687                 .dig_in_nid = ALC882_DIGIN_NID,
8688                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
8689                 .channel_mode = alc882_sixstack_modes,
8690                 .input_mux = &alc882_capture_source,
8691         },
8692         [ALC882_ARIMA] = {
8693                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
8694                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8695                                 alc882_eapd_verbs },
8696                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8697                 .dac_nids = alc882_dac_nids,
8698                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
8699                 .channel_mode = alc882_sixstack_modes,
8700                 .input_mux = &alc882_capture_source,
8701         },
8702         [ALC882_W2JC] = {
8703                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
8704                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8705                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
8706                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8707                 .dac_nids = alc882_dac_nids,
8708                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
8709                 .channel_mode = alc880_threestack_modes,
8710                 .need_dac_fix = 1,
8711                 .input_mux = &alc882_capture_source,
8712                 .dig_out_nid = ALC882_DIGOUT_NID,
8713         },
8714         [ALC885_MBP3] = {
8715                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
8716                 .init_verbs = { alc885_mbp3_init_verbs,
8717                                 alc880_gpio1_init_verbs },
8718                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8719                 .dac_nids = alc882_dac_nids,
8720                 .channel_mode = alc885_mbp_6ch_modes,
8721                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
8722                 .input_mux = &alc882_capture_source,
8723                 .dig_out_nid = ALC882_DIGOUT_NID,
8724                 .dig_in_nid = ALC882_DIGIN_NID,
8725                 .unsol_event = alc_automute_amp_unsol_event,
8726                 .init_hook = alc885_mbp3_init_hook,
8727         },
8728         [ALC885_MB5] = {
8729                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
8730                 .init_verbs = { alc885_mb5_init_verbs,
8731                                 alc880_gpio1_init_verbs },
8732                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8733                 .dac_nids = alc882_dac_nids,
8734                 .channel_mode = alc885_mb5_6ch_modes,
8735                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
8736                 .input_mux = &mb5_capture_source,
8737                 .dig_out_nid = ALC882_DIGOUT_NID,
8738                 .dig_in_nid = ALC882_DIGIN_NID,
8739         },
8740         [ALC885_MACPRO] = {
8741                 .mixers = { alc882_macpro_mixer },
8742                 .init_verbs = { alc882_macpro_init_verbs },
8743                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8744                 .dac_nids = alc882_dac_nids,
8745                 .dig_out_nid = ALC882_DIGOUT_NID,
8746                 .dig_in_nid = ALC882_DIGIN_NID,
8747                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
8748                 .channel_mode = alc882_ch_modes,
8749                 .input_mux = &alc882_capture_source,
8750                 .init_hook = alc885_macpro_init_hook,
8751         },
8752         [ALC885_IMAC24] = {
8753                 .mixers = { alc885_imac24_mixer },
8754                 .init_verbs = { alc885_imac24_init_verbs },
8755                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8756                 .dac_nids = alc882_dac_nids,
8757                 .dig_out_nid = ALC882_DIGOUT_NID,
8758                 .dig_in_nid = ALC882_DIGIN_NID,
8759                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
8760                 .channel_mode = alc882_ch_modes,
8761                 .input_mux = &alc882_capture_source,
8762                 .unsol_event = alc_automute_amp_unsol_event,
8763                 .init_hook = alc885_imac24_init_hook,
8764         },
8765         [ALC882_TARGA] = {
8766                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
8767                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8768                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
8769                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8770                 .dac_nids = alc882_dac_nids,
8771                 .dig_out_nid = ALC882_DIGOUT_NID,
8772                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
8773                 .adc_nids = alc882_adc_nids,
8774                 .capsrc_nids = alc882_capsrc_nids,
8775                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
8776                 .channel_mode = alc882_3ST_6ch_modes,
8777                 .need_dac_fix = 1,
8778                 .input_mux = &alc882_capture_source,
8779                 .unsol_event = alc882_targa_unsol_event,
8780                 .init_hook = alc882_targa_init_hook,
8781         },
8782         [ALC882_ASUS_A7J] = {
8783                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
8784                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8785                                 alc882_asus_a7j_verbs},
8786                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8787                 .dac_nids = alc882_dac_nids,
8788                 .dig_out_nid = ALC882_DIGOUT_NID,
8789                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
8790                 .adc_nids = alc882_adc_nids,
8791                 .capsrc_nids = alc882_capsrc_nids,
8792                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
8793                 .channel_mode = alc882_3ST_6ch_modes,
8794                 .need_dac_fix = 1,
8795                 .input_mux = &alc882_capture_source,
8796         },
8797         [ALC882_ASUS_A7M] = {
8798                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
8799                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8800                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
8801                                 alc882_asus_a7m_verbs },
8802                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8803                 .dac_nids = alc882_dac_nids,
8804                 .dig_out_nid = ALC882_DIGOUT_NID,
8805                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
8806                 .channel_mode = alc880_threestack_modes,
8807                 .need_dac_fix = 1,
8808                 .input_mux = &alc882_capture_source,
8809         },
8810         [ALC883_3ST_2ch_DIG] = {
8811                 .mixers = { alc883_3ST_2ch_mixer },
8812                 .init_verbs = { alc883_init_verbs },
8813                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8814                 .dac_nids = alc883_dac_nids,
8815                 .dig_out_nid = ALC883_DIGOUT_NID,
8816                 .dig_in_nid = ALC883_DIGIN_NID,
8817                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8818                 .channel_mode = alc883_3ST_2ch_modes,
8819                 .input_mux = &alc883_capture_source,
8820         },
8821         [ALC883_3ST_6ch_DIG] = {
8822                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8823                 .init_verbs = { alc883_init_verbs },
8824                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8825                 .dac_nids = alc883_dac_nids,
8826                 .dig_out_nid = ALC883_DIGOUT_NID,
8827                 .dig_in_nid = ALC883_DIGIN_NID,
8828                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8829                 .channel_mode = alc883_3ST_6ch_modes,
8830                 .need_dac_fix = 1,
8831                 .input_mux = &alc883_capture_source,
8832         },
8833         [ALC883_3ST_6ch] = {
8834                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8835                 .init_verbs = { alc883_init_verbs },
8836                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8837                 .dac_nids = alc883_dac_nids,
8838                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8839                 .channel_mode = alc883_3ST_6ch_modes,
8840                 .need_dac_fix = 1,
8841                 .input_mux = &alc883_capture_source,
8842         },
8843         [ALC883_3ST_6ch_INTEL] = {
8844                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8845                 .init_verbs = { alc883_init_verbs },
8846                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8847                 .dac_nids = alc883_dac_nids,
8848                 .dig_out_nid = ALC883_DIGOUT_NID,
8849                 .dig_in_nid = ALC883_DIGIN_NID,
8850                 .slave_dig_outs = alc883_slave_dig_outs,
8851                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8852                 .channel_mode = alc883_3ST_6ch_intel_modes,
8853                 .need_dac_fix = 1,
8854                 .input_mux = &alc883_3stack_6ch_intel,
8855         },
8856         [ALC889A_INTEL] = {
8857                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
8858                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs },
8859                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8860                 .dac_nids = alc883_dac_nids,
8861                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
8862                 .adc_nids = alc889_adc_nids,
8863                 .dig_out_nid = ALC883_DIGOUT_NID,
8864                 .dig_in_nid = ALC883_DIGIN_NID,
8865                 .slave_dig_outs = alc883_slave_dig_outs,
8866                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
8867                 .channel_mode = alc889_8ch_intel_modes,
8868                 .capsrc_nids = alc889_capsrc_nids,
8869                 .input_mux = &alc889_capture_source,
8870                 .need_dac_fix = 1,
8871         },
8872         [ALC889_INTEL] = {
8873                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
8874                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
8875                                 alc889_eapd_verbs },
8876                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8877                 .dac_nids = alc883_dac_nids,
8878                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
8879                 .adc_nids = alc889_adc_nids,
8880                 .dig_out_nid = ALC883_DIGOUT_NID,
8881                 .dig_in_nid = ALC883_DIGIN_NID,
8882                 .slave_dig_outs = alc883_slave_dig_outs,
8883                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
8884                 .channel_mode = alc889_8ch_intel_modes,
8885                 .capsrc_nids = alc889_capsrc_nids,
8886                 .input_mux = &alc889_capture_source,
8887                 .init_hook = alc889_coef_init,
8888                 .need_dac_fix = 1,
8889         },
8890         [ALC883_6ST_DIG] = {
8891                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8892                 .init_verbs = { alc883_init_verbs },
8893                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8894                 .dac_nids = alc883_dac_nids,
8895                 .dig_out_nid = ALC883_DIGOUT_NID,
8896                 .dig_in_nid = ALC883_DIGIN_NID,
8897                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8898                 .channel_mode = alc883_sixstack_modes,
8899                 .input_mux = &alc883_capture_source,
8900         },
8901         [ALC883_TARGA_DIG] = {
8902                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
8903                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
8904                                 alc883_targa_verbs},
8905                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8906                 .dac_nids = alc883_dac_nids,
8907                 .dig_out_nid = ALC883_DIGOUT_NID,
8908                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8909                 .channel_mode = alc883_3ST_6ch_modes,
8910                 .need_dac_fix = 1,
8911                 .input_mux = &alc883_capture_source,
8912                 .unsol_event = alc883_targa_unsol_event,
8913                 .init_hook = alc883_targa_init_hook,
8914         },
8915         [ALC883_TARGA_2ch_DIG] = {
8916                 .mixers = { alc883_targa_2ch_mixer},
8917                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
8918                                 alc883_targa_verbs},
8919                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8920                 .dac_nids = alc883_dac_nids,
8921                 .adc_nids = alc883_adc_nids_alt,
8922                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8923                 .dig_out_nid = ALC883_DIGOUT_NID,
8924                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8925                 .channel_mode = alc883_3ST_2ch_modes,
8926                 .input_mux = &alc883_capture_source,
8927                 .unsol_event = alc883_targa_unsol_event,
8928                 .init_hook = alc883_targa_init_hook,
8929         },
8930         [ALC883_TARGA_8ch_DIG] = {
8931                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8932                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
8933                                 alc883_targa_verbs },
8934                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8935                 .dac_nids = alc883_dac_nids,
8936                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8937                 .adc_nids = alc883_adc_nids_rev,
8938                 .capsrc_nids = alc883_capsrc_nids_rev,
8939                 .dig_out_nid = ALC883_DIGOUT_NID,
8940                 .dig_in_nid = ALC883_DIGIN_NID,
8941                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
8942                 .channel_mode = alc883_4ST_8ch_modes,
8943                 .need_dac_fix = 1,
8944                 .input_mux = &alc883_capture_source,
8945                 .unsol_event = alc883_targa_unsol_event,
8946                 .init_hook = alc883_targa_init_hook,
8947         },
8948         [ALC883_ACER] = {
8949                 .mixers = { alc883_base_mixer },
8950                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8951                  * and the headphone jack.  Turn this on and rely on the
8952                  * standard mute methods whenever the user wants to turn
8953                  * these outputs off.
8954                  */
8955                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8956                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8957                 .dac_nids = alc883_dac_nids,
8958                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8959                 .channel_mode = alc883_3ST_2ch_modes,
8960                 .input_mux = &alc883_capture_source,
8961         },
8962         [ALC883_ACER_ASPIRE] = {
8963                 .mixers = { alc883_acer_aspire_mixer },
8964                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8965                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8966                 .dac_nids = alc883_dac_nids,
8967                 .dig_out_nid = ALC883_DIGOUT_NID,
8968                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8969                 .channel_mode = alc883_3ST_2ch_modes,
8970                 .input_mux = &alc883_capture_source,
8971                 .unsol_event = alc_automute_amp_unsol_event,
8972                 .init_hook = alc883_acer_aspire_init_hook,
8973         },
8974         [ALC888_ACER_ASPIRE_4930G] = {
8975                 .mixers = { alc888_base_mixer,
8976                                 alc883_chmode_mixer },
8977                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
8978                                 alc888_acer_aspire_4930g_verbs },
8979                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8980                 .dac_nids = alc883_dac_nids,
8981                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8982                 .adc_nids = alc883_adc_nids_rev,
8983                 .capsrc_nids = alc883_capsrc_nids_rev,
8984                 .dig_out_nid = ALC883_DIGOUT_NID,
8985                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8986                 .channel_mode = alc883_3ST_6ch_modes,
8987                 .need_dac_fix = 1,
8988                 .num_mux_defs =
8989                         ARRAY_SIZE(alc888_2_capture_sources),
8990                 .input_mux = alc888_2_capture_sources,
8991                 .unsol_event = alc_automute_amp_unsol_event,
8992                 .init_hook = alc888_acer_aspire_4930g_init_hook,
8993         },
8994         [ALC888_ACER_ASPIRE_6530G] = {
8995                 .mixers = { alc888_acer_aspire_6530_mixer },
8996                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
8997                                 alc888_acer_aspire_6530g_verbs },
8998                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8999                 .dac_nids = alc883_dac_nids,
9000                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9001                 .adc_nids = alc883_adc_nids_rev,
9002                 .capsrc_nids = alc883_capsrc_nids_rev,
9003                 .dig_out_nid = ALC883_DIGOUT_NID,
9004                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9005                 .channel_mode = alc883_3ST_2ch_modes,
9006                 .num_mux_defs =
9007                         ARRAY_SIZE(alc888_2_capture_sources),
9008                 .input_mux = alc888_acer_aspire_6530_sources,
9009                 .unsol_event = alc_automute_amp_unsol_event,
9010                 .init_hook = alc888_acer_aspire_6530g_init_hook,
9011         },
9012         [ALC888_ACER_ASPIRE_8930G] = {
9013                 .mixers = { alc888_base_mixer,
9014                                 alc883_chmode_mixer },
9015                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9016                                 alc889_acer_aspire_8930g_verbs },
9017                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9018                 .dac_nids = alc883_dac_nids,
9019                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9020                 .adc_nids = alc889_adc_nids,
9021                 .capsrc_nids = alc889_capsrc_nids,
9022                 .dig_out_nid = ALC883_DIGOUT_NID,
9023                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9024                 .channel_mode = alc883_3ST_6ch_modes,
9025                 .need_dac_fix = 1,
9026                 .const_channel_count = 6,
9027                 .num_mux_defs =
9028                         ARRAY_SIZE(alc889_capture_sources),
9029                 .input_mux = alc889_capture_sources,
9030                 .unsol_event = alc_automute_amp_unsol_event,
9031                 .init_hook = alc889_acer_aspire_8930g_init_hook,
9032         },
9033         [ALC883_MEDION] = {
9034                 .mixers = { alc883_fivestack_mixer,
9035                             alc883_chmode_mixer },
9036                 .init_verbs = { alc883_init_verbs,
9037                                 alc883_medion_eapd_verbs },
9038                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9039                 .dac_nids = alc883_dac_nids,
9040                 .adc_nids = alc883_adc_nids_alt,
9041                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9042                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9043                 .channel_mode = alc883_sixstack_modes,
9044                 .input_mux = &alc883_capture_source,
9045         },
9046         [ALC883_MEDION_MD2] = {
9047                 .mixers = { alc883_medion_md2_mixer},
9048                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
9049                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9050                 .dac_nids = alc883_dac_nids,
9051                 .dig_out_nid = ALC883_DIGOUT_NID,
9052                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9053                 .channel_mode = alc883_3ST_2ch_modes,
9054                 .input_mux = &alc883_capture_source,
9055                 .unsol_event = alc_automute_amp_unsol_event,
9056                 .init_hook = alc883_medion_md2_init_hook,
9057         },
9058         [ALC883_LAPTOP_EAPD] = {
9059                 .mixers = { alc883_base_mixer },
9060                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
9061                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9062                 .dac_nids = alc883_dac_nids,
9063                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9064                 .channel_mode = alc883_3ST_2ch_modes,
9065                 .input_mux = &alc883_capture_source,
9066         },
9067         [ALC883_CLEVO_M720] = {
9068                 .mixers = { alc883_clevo_m720_mixer },
9069                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
9070                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9071                 .dac_nids = alc883_dac_nids,
9072                 .dig_out_nid = ALC883_DIGOUT_NID,
9073                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9074                 .channel_mode = alc883_3ST_2ch_modes,
9075                 .input_mux = &alc883_capture_source,
9076                 .unsol_event = alc883_clevo_m720_unsol_event,
9077                 .init_hook = alc883_clevo_m720_init_hook,
9078         },
9079         [ALC883_LENOVO_101E_2ch] = {
9080                 .mixers = { alc883_lenovo_101e_2ch_mixer},
9081                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
9082                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9083                 .dac_nids = alc883_dac_nids,
9084                 .adc_nids = alc883_adc_nids_alt,
9085                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9086                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9087                 .channel_mode = alc883_3ST_2ch_modes,
9088                 .input_mux = &alc883_lenovo_101e_capture_source,
9089                 .unsol_event = alc883_lenovo_101e_unsol_event,
9090                 .init_hook = alc883_lenovo_101e_all_automute,
9091         },
9092         [ALC883_LENOVO_NB0763] = {
9093                 .mixers = { alc883_lenovo_nb0763_mixer },
9094                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
9095                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9096                 .dac_nids = alc883_dac_nids,
9097                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9098                 .channel_mode = alc883_3ST_2ch_modes,
9099                 .need_dac_fix = 1,
9100                 .input_mux = &alc883_lenovo_nb0763_capture_source,
9101                 .unsol_event = alc_automute_amp_unsol_event,
9102                 .init_hook = alc883_medion_md2_init_hook,
9103         },
9104         [ALC888_LENOVO_MS7195_DIG] = {
9105                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9106                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
9107                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9108                 .dac_nids = alc883_dac_nids,
9109                 .dig_out_nid = ALC883_DIGOUT_NID,
9110                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9111                 .channel_mode = alc883_3ST_6ch_modes,
9112                 .need_dac_fix = 1,
9113                 .input_mux = &alc883_capture_source,
9114                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
9115                 .init_hook = alc888_lenovo_ms7195_front_automute,
9116         },
9117         [ALC883_HAIER_W66] = {
9118                 .mixers = { alc883_targa_2ch_mixer},
9119                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
9120                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9121                 .dac_nids = alc883_dac_nids,
9122                 .dig_out_nid = ALC883_DIGOUT_NID,
9123                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9124                 .channel_mode = alc883_3ST_2ch_modes,
9125                 .input_mux = &alc883_capture_source,
9126                 .unsol_event = alc_automute_amp_unsol_event,
9127                 .init_hook = alc883_haier_w66_init_hook,
9128         },
9129         [ALC888_3ST_HP] = {
9130                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9131                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9132                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9133                 .dac_nids = alc883_dac_nids,
9134                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9135                 .channel_mode = alc888_3st_hp_modes,
9136                 .need_dac_fix = 1,
9137                 .input_mux = &alc883_capture_source,
9138                 .unsol_event = alc_automute_amp_unsol_event,
9139                 .init_hook = alc888_3st_hp_init_hook,
9140         },
9141         [ALC888_6ST_DELL] = {
9142                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9143                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9144                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9145                 .dac_nids = alc883_dac_nids,
9146                 .dig_out_nid = ALC883_DIGOUT_NID,
9147                 .dig_in_nid = ALC883_DIGIN_NID,
9148                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9149                 .channel_mode = alc883_sixstack_modes,
9150                 .input_mux = &alc883_capture_source,
9151                 .unsol_event = alc_automute_amp_unsol_event,
9152                 .init_hook = alc888_6st_dell_init_hook,
9153         },
9154         [ALC883_MITAC] = {
9155                 .mixers = { alc883_mitac_mixer },
9156                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9157                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9158                 .dac_nids = alc883_dac_nids,
9159                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9160                 .channel_mode = alc883_3ST_2ch_modes,
9161                 .input_mux = &alc883_capture_source,
9162                 .unsol_event = alc_automute_amp_unsol_event,
9163                 .init_hook = alc883_mitac_init_hook,
9164         },
9165         [ALC883_FUJITSU_PI2515] = {
9166                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9167                 .init_verbs = { alc883_init_verbs,
9168                                 alc883_2ch_fujitsu_pi2515_verbs},
9169                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9170                 .dac_nids = alc883_dac_nids,
9171                 .dig_out_nid = ALC883_DIGOUT_NID,
9172                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9173                 .channel_mode = alc883_3ST_2ch_modes,
9174                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9175                 .unsol_event = alc_automute_amp_unsol_event,
9176                 .init_hook = alc883_2ch_fujitsu_pi2515_init_hook,
9177         },
9178         [ALC888_FUJITSU_XA3530] = {
9179                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
9180                 .init_verbs = { alc883_init_verbs,
9181                         alc888_fujitsu_xa3530_verbs },
9182                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9183                 .dac_nids = alc883_dac_nids,
9184                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9185                 .adc_nids = alc883_adc_nids_rev,
9186                 .capsrc_nids = alc883_capsrc_nids_rev,
9187                 .dig_out_nid = ALC883_DIGOUT_NID,
9188                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9189                 .channel_mode = alc888_4ST_8ch_intel_modes,
9190                 .num_mux_defs =
9191                         ARRAY_SIZE(alc888_2_capture_sources),
9192                 .input_mux = alc888_2_capture_sources,
9193                 .unsol_event = alc_automute_amp_unsol_event,
9194                 .init_hook = alc888_fujitsu_xa3530_init_hook,
9195         },
9196         [ALC888_LENOVO_SKY] = {
9197                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9198                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9199                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9200                 .dac_nids = alc883_dac_nids,
9201                 .dig_out_nid = ALC883_DIGOUT_NID,
9202                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9203                 .channel_mode = alc883_sixstack_modes,
9204                 .need_dac_fix = 1,
9205                 .input_mux = &alc883_lenovo_sky_capture_source,
9206                 .unsol_event = alc_automute_amp_unsol_event,
9207                 .init_hook = alc888_lenovo_sky_init_hook,
9208         },
9209         [ALC888_ASUS_M90V] = {
9210                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9211                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9212                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9213                 .dac_nids = alc883_dac_nids,
9214                 .dig_out_nid = ALC883_DIGOUT_NID,
9215                 .dig_in_nid = ALC883_DIGIN_NID,
9216                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9217                 .channel_mode = alc883_3ST_6ch_modes,
9218                 .need_dac_fix = 1,
9219                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9220                 .unsol_event = alc883_mode2_unsol_event,
9221                 .init_hook = alc883_mode2_inithook,
9222         },
9223         [ALC888_ASUS_EEE1601] = {
9224                 .mixers = { alc883_asus_eee1601_mixer },
9225                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
9226                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9227                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9228                 .dac_nids = alc883_dac_nids,
9229                 .dig_out_nid = ALC883_DIGOUT_NID,
9230                 .dig_in_nid = ALC883_DIGIN_NID,
9231                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9232                 .channel_mode = alc883_3ST_2ch_modes,
9233                 .need_dac_fix = 1,
9234                 .input_mux = &alc883_asus_eee1601_capture_source,
9235                 .unsol_event = alc_sku_unsol_event,
9236                 .init_hook = alc883_eee1601_inithook,
9237         },
9238         [ALC1200_ASUS_P5Q] = {
9239                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9240                 .init_verbs = { alc883_init_verbs },
9241                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9242                 .dac_nids = alc883_dac_nids,
9243                 .dig_out_nid = ALC1200_DIGOUT_NID,
9244                 .dig_in_nid = ALC883_DIGIN_NID,
9245                 .slave_dig_outs = alc1200_slave_dig_outs,
9246                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9247                 .channel_mode = alc883_sixstack_modes,
9248                 .input_mux = &alc883_capture_source,
9249         },
9250         [ALC889A_MB31] = {
9251                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
9252                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
9253                         alc880_gpio1_init_verbs },
9254                 .adc_nids = alc883_adc_nids,
9255                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
9256                 .dac_nids = alc883_dac_nids,
9257                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9258                 .channel_mode = alc889A_mb31_6ch_modes,
9259                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
9260                 .input_mux = &alc889A_mb31_capture_source,
9261                 .dig_out_nid = ALC883_DIGOUT_NID,
9262                 .unsol_event = alc889A_mb31_unsol_event,
9263                 .init_hook = alc889A_mb31_automute,
9264         },
9265         [ALC883_SONY_VAIO_TT] = {
9266                 .mixers = { alc883_vaiott_mixer },
9267                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
9268                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9269                 .dac_nids = alc883_dac_nids,
9270                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9271                 .channel_mode = alc883_3ST_2ch_modes,
9272                 .input_mux = &alc883_capture_source,
9273                 .unsol_event = alc_automute_amp_unsol_event,
9274                 .init_hook = alc883_vaiott_init_hook,
9275         },
9276 };
9277
9278
9279 /*
9280  * Pin config fixes
9281  */
9282 enum {
9283         PINFIX_ABIT_AW9D_MAX
9284 };
9285
9286 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
9287         { 0x15, 0x01080104 }, /* side */
9288         { 0x16, 0x01011012 }, /* rear */
9289         { 0x17, 0x01016011 }, /* clfe */
9290         { }
9291 };
9292
9293 static const struct alc_pincfg *alc882_pin_fixes[] = {
9294         [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
9295 };
9296
9297 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
9298         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
9299         {}
9300 };
9301
9302 /*
9303  * BIOS auto configuration
9304  */
9305 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
9306                                               hda_nid_t nid, int pin_type,
9307                                               int dac_idx)
9308 {
9309         /* set as output */
9310         struct alc_spec *spec = codec->spec;
9311         int idx;
9312
9313         alc_set_pin_output(codec, nid, pin_type);
9314         if (spec->multiout.dac_nids[dac_idx] == 0x25)
9315                 idx = 4;
9316         else
9317                 idx = spec->multiout.dac_nids[dac_idx] - 2;
9318         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9319
9320 }
9321
9322 static void alc882_auto_init_multi_out(struct hda_codec *codec)
9323 {
9324         struct alc_spec *spec = codec->spec;
9325         int i;
9326
9327         for (i = 0; i <= HDA_SIDE; i++) {
9328                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9329                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
9330                 if (nid)
9331                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
9332                                                           i);
9333         }
9334 }
9335
9336 static void alc882_auto_init_hp_out(struct hda_codec *codec)
9337 {
9338         struct alc_spec *spec = codec->spec;
9339         hda_nid_t pin;
9340
9341         pin = spec->autocfg.hp_pins[0];
9342         if (pin) /* connect to front */
9343                 /* use dac 0 */
9344                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9345         pin = spec->autocfg.speaker_pins[0];
9346         if (pin)
9347                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9348 }
9349
9350 static void alc882_auto_init_analog_input(struct hda_codec *codec)
9351 {
9352         struct alc_spec *spec = codec->spec;
9353         int i;
9354
9355         for (i = 0; i < AUTO_PIN_LAST; i++) {
9356                 hda_nid_t nid = spec->autocfg.input_pins[i];
9357                 if (!nid)
9358                         continue;
9359                 alc_set_input_pin(codec, nid, i);
9360                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
9361                         snd_hda_codec_write(codec, nid, 0,
9362                                             AC_VERB_SET_AMP_GAIN_MUTE,
9363                                             AMP_OUT_MUTE);
9364         }
9365 }
9366
9367 static void alc882_auto_init_input_src(struct hda_codec *codec)
9368 {
9369         struct alc_spec *spec = codec->spec;
9370         int c;
9371
9372         for (c = 0; c < spec->num_adc_nids; c++) {
9373                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
9374                 hda_nid_t nid = spec->capsrc_nids[c];
9375                 unsigned int mux_idx;
9376                 const struct hda_input_mux *imux;
9377                 int conns, mute, idx, item;
9378
9379                 conns = snd_hda_get_connections(codec, nid, conn_list,
9380                                                 ARRAY_SIZE(conn_list));
9381                 if (conns < 0)
9382                         continue;
9383                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
9384                 imux = &spec->input_mux[mux_idx];
9385                 for (idx = 0; idx < conns; idx++) {
9386                         /* if the current connection is the selected one,
9387                          * unmute it as default - otherwise mute it
9388                          */
9389                         mute = AMP_IN_MUTE(idx);
9390                         for (item = 0; item < imux->num_items; item++) {
9391                                 if (imux->items[item].index == idx) {
9392                                         if (spec->cur_mux[c] == item)
9393                                                 mute = AMP_IN_UNMUTE(idx);
9394                                         break;
9395                                 }
9396                         }
9397                         /* check if we have a selector or mixer
9398                          * we could check for the widget type instead, but
9399                          * just check for Amp-In presence (in case of mixer
9400                          * without amp-in there is something wrong, this
9401                          * function shouldn't be used or capsrc nid is wrong)
9402                          */
9403                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
9404                                 snd_hda_codec_write(codec, nid, 0,
9405                                                     AC_VERB_SET_AMP_GAIN_MUTE,
9406                                                     mute);
9407                         else if (mute != AMP_IN_MUTE(idx))
9408                                 snd_hda_codec_write(codec, nid, 0,
9409                                                     AC_VERB_SET_CONNECT_SEL,
9410                                                     idx);
9411                 }
9412         }
9413 }
9414
9415 /* add mic boosts if needed */
9416 static int alc_auto_add_mic_boost(struct hda_codec *codec)
9417 {
9418         struct alc_spec *spec = codec->spec;
9419         int err;
9420         hda_nid_t nid;
9421
9422         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
9423         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9424                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9425                                   "Mic Boost",
9426                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9427                 if (err < 0)
9428                         return err;
9429         }
9430         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
9431         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9432                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9433                                   "Front Mic Boost",
9434                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9435                 if (err < 0)
9436                         return err;
9437         }
9438         return 0;
9439 }
9440
9441 /* almost identical with ALC880 parser... */
9442 static int alc882_parse_auto_config(struct hda_codec *codec)
9443 {
9444         struct alc_spec *spec = codec->spec;
9445         struct auto_pin_cfg *autocfg = &spec->autocfg;
9446         unsigned int wcap;
9447         int i;
9448         int err = alc880_parse_auto_config(codec);
9449
9450         if (err < 0)
9451                 return err;
9452         else if (!err)
9453                 return 0; /* no config found */
9454
9455         err = alc_auto_add_mic_boost(codec);
9456         if (err < 0)
9457                 return err;
9458
9459         /* hack - override the init verbs */
9460         spec->init_verbs[0] = alc883_auto_init_verbs;
9461         /* if ADC 0x07 is available, initialize it, too */
9462         wcap = get_wcaps(codec, 0x07);
9463         wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
9464         if (wcap == AC_WID_AUD_IN)
9465                 add_verb(spec, alc882_adc1_init_verbs);
9466
9467         /* digital-mic input pin is excluded in alc880_auto_create..()
9468          * because it's under 0x18
9469          */
9470         if (autocfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
9471             autocfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
9472                 struct hda_input_mux *imux = &spec->private_imux[0];
9473                 for (i = 1; i < 3; i++)
9474                         memcpy(&spec->private_imux[i],
9475                                &spec->private_imux[0],
9476                                sizeof(spec->private_imux[0]));
9477                 imux->items[imux->num_items].label = "Int DMic";
9478                 imux->items[imux->num_items].index = 0x0b;
9479                 imux->num_items++;
9480                 spec->num_mux_defs = 3;
9481                 spec->input_mux = spec->private_imux;
9482         }
9483
9484         return 1; /* config found */
9485 }
9486
9487 /* additional initialization for auto-configuration model */
9488 static void alc882_auto_init(struct hda_codec *codec)
9489 {
9490         struct alc_spec *spec = codec->spec;
9491         alc882_auto_init_multi_out(codec);
9492         alc882_auto_init_hp_out(codec);
9493         alc882_auto_init_analog_input(codec);
9494         alc882_auto_init_input_src(codec);
9495         if (spec->unsol_event)
9496                 alc_inithook(codec);
9497 }
9498
9499 static int patch_alc882(struct hda_codec *codec)
9500 {
9501         struct alc_spec *spec;
9502         int err, board_config;
9503
9504         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9505         if (spec == NULL)
9506                 return -ENOMEM;
9507
9508         codec->spec = spec;
9509
9510         switch (codec->vendor_id) {
9511         case 0x10ec0882:
9512         case 0x10ec0885:
9513                 break;
9514         default:
9515                 /* ALC883 and variants */
9516                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9517                 break;
9518         }
9519
9520         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
9521                                                   alc882_models,
9522                                                   alc882_cfg_tbl);
9523
9524         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
9525                 board_config = snd_hda_check_board_codec_sid_config(codec,
9526                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
9527
9528         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
9529                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
9530                        "trying auto-probe from BIOS...\n",
9531                        codec->chip_name);
9532                 board_config = ALC882_AUTO;
9533         }
9534
9535         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
9536
9537         if (board_config == ALC882_AUTO) {
9538                 /* automatic parse from the BIOS config */
9539                 err = alc882_parse_auto_config(codec);
9540                 if (err < 0) {
9541                         alc_free(codec);
9542                         return err;
9543                 } else if (!err) {
9544                         printk(KERN_INFO
9545                                "hda_codec: Cannot set up configuration "
9546                                "from BIOS.  Using base mode...\n");
9547                         board_config = ALC882_3ST_DIG;
9548                 }
9549         }
9550
9551         err = snd_hda_attach_beep_device(codec, 0x1);
9552         if (err < 0) {
9553                 alc_free(codec);
9554                 return err;
9555         }
9556
9557         if (board_config != ALC882_AUTO)
9558                 setup_preset(spec, &alc882_presets[board_config]);
9559
9560         spec->stream_analog_playback = &alc882_pcm_analog_playback;
9561         spec->stream_analog_capture = &alc882_pcm_analog_capture;
9562         /* FIXME: setup DAC5 */
9563         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
9564         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
9565
9566         spec->stream_digital_playback = &alc882_pcm_digital_playback;
9567         spec->stream_digital_capture = &alc882_pcm_digital_capture;
9568
9569         if (codec->vendor_id == 0x10ec0888)
9570                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
9571
9572         if (!spec->adc_nids && spec->input_mux) {
9573                 int i;
9574                 spec->num_adc_nids = 0;
9575                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
9576                         hda_nid_t cap;
9577                         hda_nid_t nid = alc882_adc_nids[i];
9578                         unsigned int wcap = get_wcaps(codec, nid);
9579                         /* get type */
9580                         wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
9581                         if (wcap != AC_WID_AUD_IN)
9582                                 continue;
9583                         spec->private_adc_nids[spec->num_adc_nids] = nid;
9584                         err = snd_hda_get_connections(codec, nid, &cap, 1);
9585                         if (err < 0)
9586                                 continue;
9587                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
9588                         spec->num_adc_nids++;
9589                 }
9590                 spec->adc_nids = spec->private_adc_nids;
9591                 spec->capsrc_nids = spec->private_capsrc_nids;
9592         }
9593
9594         set_capture_mixer(spec);
9595         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9596
9597         spec->vmaster_nid = 0x0c;
9598
9599         codec->patch_ops = alc_patch_ops;
9600         if (board_config == ALC882_AUTO)
9601                 spec->init_hook = alc882_auto_init;
9602 #ifdef CONFIG_SND_HDA_POWER_SAVE
9603         if (!spec->loopback.amplist)
9604                 spec->loopback.amplist = alc882_loopbacks;
9605 #endif
9606         codec->proc_widget_hook = print_realtek_coef;
9607
9608         return 0;
9609 }
9610
9611
9612 /*
9613  * ALC262 support
9614  */
9615
9616 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
9617 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
9618
9619 #define alc262_dac_nids         alc260_dac_nids
9620 #define alc262_adc_nids         alc882_adc_nids
9621 #define alc262_adc_nids_alt     alc882_adc_nids_alt
9622 #define alc262_capsrc_nids      alc882_capsrc_nids
9623 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
9624
9625 #define alc262_modes            alc260_modes
9626 #define alc262_capture_source   alc882_capture_source
9627
9628 static hda_nid_t alc262_dmic_adc_nids[1] = {
9629         /* ADC0 */
9630         0x09
9631 };
9632
9633 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
9634
9635 static struct snd_kcontrol_new alc262_base_mixer[] = {
9636         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9637         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9638         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9639         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9640         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9641         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9642         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9643         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9644         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9645         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9646         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9647         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9648         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
9649         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9650         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9651         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
9652         { } /* end */
9653 };
9654
9655 /* update HP, line and mono-out pins according to the master switch */
9656 static void alc262_hp_master_update(struct hda_codec *codec)
9657 {
9658         struct alc_spec *spec = codec->spec;
9659         int val = spec->master_sw;
9660
9661         /* HP & line-out */
9662         snd_hda_codec_write_cache(codec, 0x1b, 0,
9663                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9664                                   val ? PIN_HP : 0);
9665         snd_hda_codec_write_cache(codec, 0x15, 0,
9666                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9667                                   val ? PIN_HP : 0);
9668         /* mono (speaker) depending on the HP jack sense */
9669         val = val && !spec->jack_present;
9670         snd_hda_codec_write_cache(codec, 0x16, 0,
9671                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9672                                   val ? PIN_OUT : 0);
9673 }
9674
9675 static void alc262_hp_bpc_automute(struct hda_codec *codec)
9676 {
9677         struct alc_spec *spec = codec->spec;
9678         unsigned int presence;
9679         presence = snd_hda_codec_read(codec, 0x1b, 0,
9680                                       AC_VERB_GET_PIN_SENSE, 0);
9681         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9682         alc262_hp_master_update(codec);
9683 }
9684
9685 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
9686 {
9687         if ((res >> 26) != ALC880_HP_EVENT)
9688                 return;
9689         alc262_hp_bpc_automute(codec);
9690 }
9691
9692 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
9693 {
9694         struct alc_spec *spec = codec->spec;
9695         unsigned int presence;
9696         presence = snd_hda_codec_read(codec, 0x15, 0,
9697                                       AC_VERB_GET_PIN_SENSE, 0);
9698         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9699         alc262_hp_master_update(codec);
9700 }
9701
9702 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
9703                                            unsigned int res)
9704 {
9705         if ((res >> 26) != ALC880_HP_EVENT)
9706                 return;
9707         alc262_hp_wildwest_automute(codec);
9708 }
9709
9710 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
9711
9712 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9713                                    struct snd_ctl_elem_value *ucontrol)
9714 {
9715         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9716         struct alc_spec *spec = codec->spec;
9717         int val = !!*ucontrol->value.integer.value;
9718
9719         if (val == spec->master_sw)
9720                 return 0;
9721         spec->master_sw = val;
9722         alc262_hp_master_update(codec);
9723         return 1;
9724 }
9725
9726 #define ALC262_HP_MASTER_SWITCH                                 \
9727         {                                                       \
9728                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
9729                 .name = "Master Playback Switch",               \
9730                 .info = snd_ctl_boolean_mono_info,              \
9731                 .get = alc262_hp_master_sw_get,                 \
9732                 .put = alc262_hp_master_sw_put,                 \
9733         }
9734
9735 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9736         ALC262_HP_MASTER_SWITCH,
9737         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9738         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9739         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9740         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9741                               HDA_OUTPUT),
9742         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9743                             HDA_OUTPUT),
9744         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9745         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9746         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9747         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9748         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9749         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9750         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9751         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9752         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9753         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9754         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9755         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9756         { } /* end */
9757 };
9758
9759 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9760         ALC262_HP_MASTER_SWITCH,
9761         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9762         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9763         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9764         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9765         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9766                               HDA_OUTPUT),
9767         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9768                             HDA_OUTPUT),
9769         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9770         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9771         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9772         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9773         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9774         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9775         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9776         { } /* end */
9777 };
9778
9779 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9780         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9781         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9782         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9783         { } /* end */
9784 };
9785
9786 /* mute/unmute internal speaker according to the hp jack and mute state */
9787 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9788 {
9789         struct alc_spec *spec = codec->spec;
9790
9791         spec->autocfg.hp_pins[0] = 0x15;
9792         spec->autocfg.speaker_pins[0] = 0x0c; /* HACK: not actually a pin */
9793         alc_automute_amp(codec);
9794 }
9795
9796 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9797         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9798         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9799         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9800         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9801         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9802         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9803         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9804         { } /* end */
9805 };
9806
9807 static struct hda_verb alc262_hp_t5735_verbs[] = {
9808         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9809         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9810
9811         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9812         { }
9813 };
9814
9815 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9816         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9817         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9818         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9819         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9820         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9821         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9822         { } /* end */
9823 };
9824
9825 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9826         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9827         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9828         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9829         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9830         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9831         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9832         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9833         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9834         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9835         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9836         {}
9837 };
9838
9839 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9840         .num_items = 1,
9841         .items = {
9842                 { "Line", 0x1 },
9843         },
9844 };
9845
9846 /* bind hp and internal speaker mute (with plug check) as master switch */
9847 static void alc262_hippo_master_update(struct hda_codec *codec)
9848 {
9849         struct alc_spec *spec = codec->spec;
9850         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
9851         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
9852         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
9853         unsigned int mute;
9854
9855         /* HP */
9856         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
9857         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
9858                                  HDA_AMP_MUTE, mute);
9859         /* mute internal speaker per jack sense */
9860         if (spec->jack_present)
9861                 mute = HDA_AMP_MUTE;
9862         if (line_nid)
9863                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
9864                                          HDA_AMP_MUTE, mute);
9865         if (speaker_nid && speaker_nid != line_nid)
9866                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
9867                                          HDA_AMP_MUTE, mute);
9868 }
9869
9870 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
9871
9872 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
9873                                       struct snd_ctl_elem_value *ucontrol)
9874 {
9875         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9876         struct alc_spec *spec = codec->spec;
9877         int val = !!*ucontrol->value.integer.value;
9878
9879         if (val == spec->master_sw)
9880                 return 0;
9881         spec->master_sw = val;
9882         alc262_hippo_master_update(codec);
9883         return 1;
9884 }
9885
9886 #define ALC262_HIPPO_MASTER_SWITCH                              \
9887         {                                                       \
9888                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
9889                 .name = "Master Playback Switch",               \
9890                 .info = snd_ctl_boolean_mono_info,              \
9891                 .get = alc262_hippo_master_sw_get,              \
9892                 .put = alc262_hippo_master_sw_put,              \
9893         }
9894
9895 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
9896         ALC262_HIPPO_MASTER_SWITCH,
9897         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9898         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9899         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9900         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9901         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9902         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9903         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9904         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9905         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9906         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9907         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9908         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9909         { } /* end */
9910 };
9911
9912 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
9913         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9914         ALC262_HIPPO_MASTER_SWITCH,
9915         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9916         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9917         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9918         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9919         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9920         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9921         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9922         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9923         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9924         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9925         { } /* end */
9926 };
9927
9928 /* mute/unmute internal speaker according to the hp jack and mute state */
9929 static void alc262_hippo_automute(struct hda_codec *codec)
9930 {
9931         struct alc_spec *spec = codec->spec;
9932         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
9933         unsigned int present;
9934
9935         /* need to execute and sync at first */
9936         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
9937         present = snd_hda_codec_read(codec, hp_nid, 0,
9938                                      AC_VERB_GET_PIN_SENSE, 0);
9939         spec->jack_present = (present & 0x80000000) != 0;
9940         alc262_hippo_master_update(codec);
9941 }
9942
9943 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
9944 {
9945         if ((res >> 26) != ALC880_HP_EVENT)
9946                 return;
9947         alc262_hippo_automute(codec);
9948 }
9949
9950 static void alc262_hippo_init_hook(struct hda_codec *codec)
9951 {
9952         struct alc_spec *spec = codec->spec;
9953
9954         spec->autocfg.hp_pins[0] = 0x15;
9955         spec->autocfg.speaker_pins[0] = 0x14;
9956         alc262_hippo_automute(codec);
9957 }
9958
9959 static void alc262_hippo1_init_hook(struct hda_codec *codec)
9960 {
9961         struct alc_spec *spec = codec->spec;
9962
9963         spec->autocfg.hp_pins[0] = 0x1b;
9964         spec->autocfg.speaker_pins[0] = 0x14;
9965         alc262_hippo_automute(codec);
9966 }
9967
9968
9969 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9970         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9971         ALC262_HIPPO_MASTER_SWITCH,
9972         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9973         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9974         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9975         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9976         { } /* end */
9977 };
9978
9979 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9980         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9981         ALC262_HIPPO_MASTER_SWITCH,
9982         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9983         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9984         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9985         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9986         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9987         { } /* end */
9988 };
9989
9990 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
9991         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9992         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9993         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
9994         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
9995         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9996         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9997         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9998         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9999         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10000         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10001         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10002         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10003         { } /* end */
10004 };
10005
10006 static struct hda_verb alc262_tyan_verbs[] = {
10007         /* Headphone automute */
10008         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10009         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10010         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10011
10012         /* P11 AUX_IN, white 4-pin connector */
10013         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10014         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
10015         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
10016         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
10017
10018         {}
10019 };
10020
10021 /* unsolicited event for HP jack sensing */
10022 static void alc262_tyan_init_hook(struct hda_codec *codec)
10023 {
10024         struct alc_spec *spec = codec->spec;
10025
10026         spec->autocfg.hp_pins[0] = 0x1b;
10027         spec->autocfg.speaker_pins[0] = 0x15;
10028         alc_automute_amp(codec);
10029 }
10030
10031
10032 #define alc262_capture_mixer            alc882_capture_mixer
10033 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
10034
10035 /*
10036  * generic initialization of ADC, input mixers and output mixers
10037  */
10038 static struct hda_verb alc262_init_verbs[] = {
10039         /*
10040          * Unmute ADC0-2 and set the default input to mic-in
10041          */
10042         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10043         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10044         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10045         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10046         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10047         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10048
10049         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10050          * mixer widget
10051          * Note: PASD motherboards uses the Line In 2 as the input for
10052          * front panel mic (mic 2)
10053          */
10054         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10055         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10056         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10057         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10058         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10059         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10060
10061         /*
10062          * Set up output mixers (0x0c - 0x0e)
10063          */
10064         /* set vol=0 to output mixers */
10065         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10066         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10067         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10068         /* set up input amps for analog loopback */
10069         /* Amp Indices: DAC = 0, mixer = 1 */
10070         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10071         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10072         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10073         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10074         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10075         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10076
10077         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10078         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10079         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10080         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10081         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10082         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10083
10084         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10085         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10086         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10087         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10088         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10089
10090         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10091         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10092
10093         /* FIXME: use matrix-type input source selection */
10094         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10095         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10096         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10097         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10098         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10099         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10100         /* Input mixer2 */
10101         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10102         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10103         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10104         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10105         /* Input mixer3 */
10106         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10107         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10108         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10109         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10110
10111         { }
10112 };
10113
10114 static struct hda_verb alc262_eapd_verbs[] = {
10115         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10116         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10117         { }
10118 };
10119
10120 static struct hda_verb alc262_hippo_unsol_verbs[] = {
10121         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10122         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10123         {}
10124 };
10125
10126 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
10127         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10128         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10129         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10130
10131         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10132         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10133         {}
10134 };
10135
10136 static struct hda_verb alc262_sony_unsol_verbs[] = {
10137         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10138         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10139         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
10140
10141         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10142         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10143         {}
10144 };
10145
10146 static struct hda_input_mux alc262_dmic_capture_source = {
10147         .num_items = 2,
10148         .items = {
10149                 { "Int DMic", 0x9 },
10150                 { "Mic", 0x0 },
10151         },
10152 };
10153
10154 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
10155         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10156         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10157         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10158         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10159         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10160         { } /* end */
10161 };
10162
10163 static struct hda_verb alc262_toshiba_s06_verbs[] = {
10164         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10165         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10166         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10167         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10168         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
10169         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10170         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10171         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10172         {}
10173 };
10174
10175 static void alc262_dmic_automute(struct hda_codec *codec)
10176 {
10177         unsigned int present;
10178
10179         present = snd_hda_codec_read(codec, 0x18, 0,
10180                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
10181         snd_hda_codec_write(codec, 0x22, 0,
10182                                 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
10183 }
10184
10185
10186 /* unsolicited event for HP jack sensing */
10187 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
10188                                        unsigned int res)
10189 {
10190         if ((res >> 26) == ALC880_MIC_EVENT)
10191                 alc262_dmic_automute(codec);
10192         else
10193                 alc_sku_unsol_event(codec, res);
10194 }
10195
10196 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
10197 {
10198         struct alc_spec *spec = codec->spec;
10199
10200         spec->autocfg.hp_pins[0] = 0x15;
10201         spec->autocfg.speaker_pins[0] = 0x14;
10202         alc_automute_pin(codec);
10203         alc262_dmic_automute(codec);
10204 }
10205
10206 /*
10207  * nec model
10208  *  0x15 = headphone
10209  *  0x16 = internal speaker
10210  *  0x18 = external mic
10211  */
10212
10213 static struct snd_kcontrol_new alc262_nec_mixer[] = {
10214         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
10215         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
10216
10217         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10218         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10219         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10220
10221         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10222         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10223         { } /* end */
10224 };
10225
10226 static struct hda_verb alc262_nec_verbs[] = {
10227         /* Unmute Speaker */
10228         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10229
10230         /* Headphone */
10231         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10232         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10233
10234         /* External mic to headphone */
10235         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10236         /* External mic to speaker */
10237         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10238         {}
10239 };
10240
10241 /*
10242  * fujitsu model
10243  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10244  *  0x1b = port replicator headphone out
10245  */
10246
10247 #define ALC_HP_EVENT    0x37
10248
10249 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10250         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10251         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10252         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10253         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10254         {}
10255 };
10256
10257 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10258         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10259         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10260         {}
10261 };
10262
10263 static struct hda_input_mux alc262_fujitsu_capture_source = {
10264         .num_items = 3,
10265         .items = {
10266                 { "Mic", 0x0 },
10267                 { "Int Mic", 0x1 },
10268                 { "CD", 0x4 },
10269         },
10270 };
10271
10272 static struct hda_input_mux alc262_HP_capture_source = {
10273         .num_items = 5,
10274         .items = {
10275                 { "Mic", 0x0 },
10276                 { "Front Mic", 0x1 },
10277                 { "Line", 0x2 },
10278                 { "CD", 0x4 },
10279                 { "AUX IN", 0x6 },
10280         },
10281 };
10282
10283 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10284         .num_items = 4,
10285         .items = {
10286                 { "Mic", 0x0 },
10287                 { "Front Mic", 0x2 },
10288                 { "Line", 0x1 },
10289                 { "CD", 0x4 },
10290         },
10291 };
10292
10293 /* mute/unmute internal speaker according to the hp jacks and mute state */
10294 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10295 {
10296         struct alc_spec *spec = codec->spec;
10297         unsigned int mute;
10298
10299         if (force || !spec->sense_updated) {
10300                 unsigned int present;
10301                 /* need to execute and sync at first */
10302                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
10303                 /* check laptop HP jack */
10304                 present = snd_hda_codec_read(codec, 0x14, 0,
10305                                              AC_VERB_GET_PIN_SENSE, 0);
10306                 /* need to execute and sync at first */
10307                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10308                 /* check docking HP jack */
10309                 present |= snd_hda_codec_read(codec, 0x1b, 0,
10310                                               AC_VERB_GET_PIN_SENSE, 0);
10311                 if (present & AC_PINSENSE_PRESENCE)
10312                         spec->jack_present = 1;
10313                 else
10314                         spec->jack_present = 0;
10315                 spec->sense_updated = 1;
10316         }
10317         /* unmute internal speaker only if both HPs are unplugged and
10318          * master switch is on
10319          */
10320         if (spec->jack_present)
10321                 mute = HDA_AMP_MUTE;
10322         else
10323                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10324         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10325                                  HDA_AMP_MUTE, mute);
10326 }
10327
10328 /* unsolicited event for HP jack sensing */
10329 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10330                                        unsigned int res)
10331 {
10332         if ((res >> 26) != ALC_HP_EVENT)
10333                 return;
10334         alc262_fujitsu_automute(codec, 1);
10335 }
10336
10337 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10338 {
10339         alc262_fujitsu_automute(codec, 1);
10340 }
10341
10342 /* bind volumes of both NID 0x0c and 0x0d */
10343 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10344         .ops = &snd_hda_bind_vol,
10345         .values = {
10346                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10347                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10348                 0
10349         },
10350 };
10351
10352 /* mute/unmute internal speaker according to the hp jack and mute state */
10353 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10354 {
10355         struct alc_spec *spec = codec->spec;
10356         unsigned int mute;
10357
10358         if (force || !spec->sense_updated) {
10359                 unsigned int present_int_hp;
10360                 /* need to execute and sync at first */
10361                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10362                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
10363                                         AC_VERB_GET_PIN_SENSE, 0);
10364                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
10365                 spec->sense_updated = 1;
10366         }
10367         if (spec->jack_present) {
10368                 /* mute internal speaker */
10369                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10370                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10371                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10372                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10373         } else {
10374                 /* unmute internal speaker if necessary */
10375                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10376                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10377                                          HDA_AMP_MUTE, mute);
10378                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10379                                          HDA_AMP_MUTE, mute);
10380         }
10381 }
10382
10383 /* unsolicited event for HP jack sensing */
10384 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10385                                        unsigned int res)
10386 {
10387         if ((res >> 26) != ALC_HP_EVENT)
10388                 return;
10389         alc262_lenovo_3000_automute(codec, 1);
10390 }
10391
10392 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
10393                                   int dir, int idx, long *valp)
10394 {
10395         int i, change = 0;
10396
10397         for (i = 0; i < 2; i++, valp++)
10398                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
10399                                                    HDA_AMP_MUTE,
10400                                                    *valp ? 0 : HDA_AMP_MUTE);
10401         return change;
10402 }
10403
10404 /* bind hp and internal speaker mute (with plug check) */
10405 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10406                                          struct snd_ctl_elem_value *ucontrol)
10407 {
10408         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10409         long *valp = ucontrol->value.integer.value;
10410         int change;
10411
10412         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
10413         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10414         if (change)
10415                 alc262_fujitsu_automute(codec, 0);
10416         return change;
10417 }
10418
10419 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10420         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10421         {
10422                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10423                 .name = "Master Playback Switch",
10424                 .info = snd_hda_mixer_amp_switch_info,
10425                 .get = snd_hda_mixer_amp_switch_get,
10426                 .put = alc262_fujitsu_master_sw_put,
10427                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10428         },
10429         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10430         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10431         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10432         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10433         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10434         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10435         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10436         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10437         { } /* end */
10438 };
10439
10440 /* bind hp and internal speaker mute (with plug check) */
10441 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10442                                          struct snd_ctl_elem_value *ucontrol)
10443 {
10444         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10445         long *valp = ucontrol->value.integer.value;
10446         int change;
10447
10448         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10449         if (change)
10450                 alc262_lenovo_3000_automute(codec, 0);
10451         return change;
10452 }
10453
10454 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10455         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10456         {
10457                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10458                 .name = "Master Playback Switch",
10459                 .info = snd_hda_mixer_amp_switch_info,
10460                 .get = snd_hda_mixer_amp_switch_get,
10461                 .put = alc262_lenovo_3000_master_sw_put,
10462                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10463         },
10464         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10465         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10466         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10467         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10468         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10469         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10470         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10471         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10472         { } /* end */
10473 };
10474
10475 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10476         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10477         ALC262_HIPPO_MASTER_SWITCH,
10478         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10479         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10480         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10481         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10482         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10483         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10484         { } /* end */
10485 };
10486
10487 /* additional init verbs for Benq laptops */
10488 static struct hda_verb alc262_EAPD_verbs[] = {
10489         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10490         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10491         {}
10492 };
10493
10494 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10495         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10496         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10497
10498         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10499         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10500         {}
10501 };
10502
10503 /* Samsung Q1 Ultra Vista model setup */
10504 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10505         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10506         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10507         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10508         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10509         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10510         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10511         { } /* end */
10512 };
10513
10514 static struct hda_verb alc262_ultra_verbs[] = {
10515         /* output mixer */
10516         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10517         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10518         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10519         /* speaker */
10520         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10521         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10522         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10523         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10524         /* HP */
10525         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10526         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10527         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10528         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10529         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10530         /* internal mic */
10531         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10532         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10533         /* ADC, choose mic */
10534         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10535         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10536         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10537         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10538         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10539         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10540         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10541         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10542         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10543         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
10544         {}
10545 };
10546
10547 /* mute/unmute internal speaker according to the hp jack and mute state */
10548 static void alc262_ultra_automute(struct hda_codec *codec)
10549 {
10550         struct alc_spec *spec = codec->spec;
10551         unsigned int mute;
10552
10553         mute = 0;
10554         /* auto-mute only when HP is used as HP */
10555         if (!spec->cur_mux[0]) {
10556                 unsigned int present;
10557                 /* need to execute and sync at first */
10558                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
10559                 present = snd_hda_codec_read(codec, 0x15, 0,
10560                                              AC_VERB_GET_PIN_SENSE, 0);
10561                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
10562                 if (spec->jack_present)
10563                         mute = HDA_AMP_MUTE;
10564         }
10565         /* mute/unmute internal speaker */
10566         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10567                                  HDA_AMP_MUTE, mute);
10568         /* mute/unmute HP */
10569         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10570                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
10571 }
10572
10573 /* unsolicited event for HP jack sensing */
10574 static void alc262_ultra_unsol_event(struct hda_codec *codec,
10575                                        unsigned int res)
10576 {
10577         if ((res >> 26) != ALC880_HP_EVENT)
10578                 return;
10579         alc262_ultra_automute(codec);
10580 }
10581
10582 static struct hda_input_mux alc262_ultra_capture_source = {
10583         .num_items = 2,
10584         .items = {
10585                 { "Mic", 0x1 },
10586                 { "Headphone", 0x7 },
10587         },
10588 };
10589
10590 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
10591                                      struct snd_ctl_elem_value *ucontrol)
10592 {
10593         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10594         struct alc_spec *spec = codec->spec;
10595         int ret;
10596
10597         ret = alc_mux_enum_put(kcontrol, ucontrol);
10598         if (!ret)
10599                 return 0;
10600         /* reprogram the HP pin as mic or HP according to the input source */
10601         snd_hda_codec_write_cache(codec, 0x15, 0,
10602                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10603                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
10604         alc262_ultra_automute(codec); /* mute/unmute HP */
10605         return ret;
10606 }
10607
10608 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
10609         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10610         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10611         {
10612                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10613                 .name = "Capture Source",
10614                 .info = alc_mux_enum_info,
10615                 .get = alc_mux_enum_get,
10616                 .put = alc262_ultra_mux_enum_put,
10617         },
10618         { } /* end */
10619 };
10620
10621 /* add playback controls from the parsed DAC table */
10622 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
10623                                              const struct auto_pin_cfg *cfg)
10624 {
10625         hda_nid_t nid;
10626         int err;
10627
10628         spec->multiout.num_dacs = 1;    /* only use one dac */
10629         spec->multiout.dac_nids = spec->private_dac_nids;
10630         spec->multiout.dac_nids[0] = 2;
10631
10632         nid = cfg->line_out_pins[0];
10633         if (nid) {
10634                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10635                                   "Front Playback Volume",
10636                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
10637                 if (err < 0)
10638                         return err;
10639                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10640                                   "Front Playback Switch",
10641                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10642                 if (err < 0)
10643                         return err;
10644         }
10645
10646         nid = cfg->speaker_pins[0];
10647         if (nid) {
10648                 if (nid == 0x16) {
10649                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10650                                           "Speaker Playback Volume",
10651                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10652                                                               HDA_OUTPUT));
10653                         if (err < 0)
10654                                 return err;
10655                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10656                                           "Speaker Playback Switch",
10657                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10658                                                               HDA_OUTPUT));
10659                         if (err < 0)
10660                                 return err;
10661                 } else {
10662                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10663                                           "Speaker Playback Switch",
10664                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10665                                                               HDA_OUTPUT));
10666                         if (err < 0)
10667                                 return err;
10668                 }
10669         }
10670         nid = cfg->hp_pins[0];
10671         if (nid) {
10672                 /* spec->multiout.hp_nid = 2; */
10673                 if (nid == 0x16) {
10674                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10675                                           "Headphone Playback Volume",
10676                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10677                                                               HDA_OUTPUT));
10678                         if (err < 0)
10679                                 return err;
10680                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10681                                           "Headphone Playback Switch",
10682                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10683                                                               HDA_OUTPUT));
10684                         if (err < 0)
10685                                 return err;
10686                 } else {
10687                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10688                                           "Headphone Playback Switch",
10689                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10690                                                               HDA_OUTPUT));
10691                         if (err < 0)
10692                                 return err;
10693                 }
10694         }
10695         return 0;
10696 }
10697
10698 static int alc262_auto_create_analog_input_ctls(struct alc_spec *spec,
10699                                                 const struct auto_pin_cfg *cfg)
10700 {
10701         int err;
10702
10703         err = alc880_auto_create_analog_input_ctls(spec, cfg);
10704         if (err < 0)
10705                 return err;
10706         /* digital-mic input pin is excluded in alc880_auto_create..()
10707          * because it's under 0x18
10708          */
10709         if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
10710             cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
10711                 struct hda_input_mux *imux = &spec->private_imux[0];
10712                 imux->items[imux->num_items].label = "Int Mic";
10713                 imux->items[imux->num_items].index = 0x09;
10714                 imux->num_items++;
10715         }
10716         return 0;
10717 }
10718
10719
10720 /*
10721  * generic initialization of ADC, input mixers and output mixers
10722  */
10723 static struct hda_verb alc262_volume_init_verbs[] = {
10724         /*
10725          * Unmute ADC0-2 and set the default input to mic-in
10726          */
10727         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10728         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10729         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10730         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10731         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10732         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10733
10734         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10735          * mixer widget
10736          * Note: PASD motherboards uses the Line In 2 as the input for
10737          * front panel mic (mic 2)
10738          */
10739         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10740         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10741         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10742         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10743         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10744         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10745
10746         /*
10747          * Set up output mixers (0x0c - 0x0f)
10748          */
10749         /* set vol=0 to output mixers */
10750         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10751         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10752         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10753
10754         /* set up input amps for analog loopback */
10755         /* Amp Indices: DAC = 0, mixer = 1 */
10756         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10757         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10758         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10759         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10760         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10761         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10762
10763         /* FIXME: use matrix-type input source selection */
10764         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10765         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10766         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10767         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10768         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10769         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10770         /* Input mixer2 */
10771         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10772         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10773         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10774         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10775         /* Input mixer3 */
10776         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10777         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10778         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10779         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10780
10781         { }
10782 };
10783
10784 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10785         /*
10786          * Unmute ADC0-2 and set the default input to mic-in
10787          */
10788         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10789         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10790         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10791         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10792         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10793         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10794
10795         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10796          * mixer widget
10797          * Note: PASD motherboards uses the Line In 2 as the input for
10798          * front panel mic (mic 2)
10799          */
10800         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10801         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10802         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10803         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10804         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10805         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10806         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10807         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10808
10809         /*
10810          * Set up output mixers (0x0c - 0x0e)
10811          */
10812         /* set vol=0 to output mixers */
10813         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10814         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10815         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10816
10817         /* set up input amps for analog loopback */
10818         /* Amp Indices: DAC = 0, mixer = 1 */
10819         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10820         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10821         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10822         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10823         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10824         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10825
10826         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10827         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10828         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10829
10830         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10831         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10832
10833         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10834         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10835
10836         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10837         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10838         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10839         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10840         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10841
10842         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10843         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10844         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10845         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10846         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10847         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10848
10849
10850         /* FIXME: use matrix-type input source selection */
10851         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
10852         /* Input mixer1: only unmute Mic */
10853         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10854         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
10855         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10856         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10857         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10858         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
10859         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
10860         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
10861         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
10862         /* Input mixer2 */
10863         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10864         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
10865         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10866         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10867         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10868         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
10869         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
10870         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
10871         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
10872         /* Input mixer3 */
10873         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10874         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
10875         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10876         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10877         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10878         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
10879         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
10880         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
10881         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
10882
10883         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10884
10885         { }
10886 };
10887
10888 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10889         /*
10890          * Unmute ADC0-2 and set the default input to mic-in
10891          */
10892         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10893         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10894         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10895         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10896         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10897         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10898
10899         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10900          * mixer widget
10901          * Note: PASD motherboards uses the Line In 2 as the input for front
10902          * panel mic (mic 2)
10903          */
10904         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10905         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10906         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10907         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10908         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10909         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10910         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10911         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10912         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10913         /*
10914          * Set up output mixers (0x0c - 0x0e)
10915          */
10916         /* set vol=0 to output mixers */
10917         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10918         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10919         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10920
10921         /* set up input amps for analog loopback */
10922         /* Amp Indices: DAC = 0, mixer = 1 */
10923         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10924         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10925         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10926         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10927         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10928         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10929
10930
10931         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
10932         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
10933         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
10934         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
10935         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10936         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
10937         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
10938
10939         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10940         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10941
10942         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10943         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10944
10945         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10946         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10947         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10948         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10949         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10950         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10951
10952         /* FIXME: use matrix-type input source selection */
10953         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10954         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10955         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10956         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10957         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10958         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10959         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10960         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
10961         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10962         /* Input mixer2 */
10963         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10964         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10965         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10966         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10967         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10968         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10969         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10970         /* Input mixer3 */
10971         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10972         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10973         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10974         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10975         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10976         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10977         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10978
10979         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10980
10981         { }
10982 };
10983
10984 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10985
10986         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
10987         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10988         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10989
10990         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
10991         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10992         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10993         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10994
10995         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
10996         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10997         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10998         {}
10999 };
11000
11001
11002 #ifdef CONFIG_SND_HDA_POWER_SAVE
11003 #define alc262_loopbacks        alc880_loopbacks
11004 #endif
11005
11006 /* pcm configuration: identical with ALC880 */
11007 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
11008 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
11009 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
11010 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
11011
11012 /*
11013  * BIOS auto configuration
11014  */
11015 static int alc262_parse_auto_config(struct hda_codec *codec)
11016 {
11017         struct alc_spec *spec = codec->spec;
11018         int err;
11019         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
11020
11021         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11022                                            alc262_ignore);
11023         if (err < 0)
11024                 return err;
11025         if (!spec->autocfg.line_outs) {
11026                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11027                         spec->multiout.max_channels = 2;
11028                         spec->no_analog = 1;
11029                         goto dig_only;
11030                 }
11031                 return 0; /* can't find valid BIOS pin config */
11032         }
11033         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
11034         if (err < 0)
11035                 return err;
11036         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
11037         if (err < 0)
11038                 return err;
11039
11040         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11041
11042  dig_only:
11043         if (spec->autocfg.dig_outs) {
11044                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
11045                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11046         }
11047         if (spec->autocfg.dig_in_pin)
11048                 spec->dig_in_nid = ALC262_DIGIN_NID;
11049
11050         if (spec->kctls.list)
11051                 add_mixer(spec, spec->kctls.list);
11052
11053         add_verb(spec, alc262_volume_init_verbs);
11054         spec->num_mux_defs = 1;
11055         spec->input_mux = &spec->private_imux[0];
11056
11057         err = alc_auto_add_mic_boost(codec);
11058         if (err < 0)
11059                 return err;
11060
11061         alc_ssid_check(codec, 0x15, 0x14, 0x1b);
11062
11063         return 1;
11064 }
11065
11066 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
11067 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
11068 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
11069 #define alc262_auto_init_input_src      alc882_auto_init_input_src
11070
11071
11072 /* init callback for auto-configuration model -- overriding the default init */
11073 static void alc262_auto_init(struct hda_codec *codec)
11074 {
11075         struct alc_spec *spec = codec->spec;
11076         alc262_auto_init_multi_out(codec);
11077         alc262_auto_init_hp_out(codec);
11078         alc262_auto_init_analog_input(codec);
11079         alc262_auto_init_input_src(codec);
11080         if (spec->unsol_event)
11081                 alc_inithook(codec);
11082 }
11083
11084 /*
11085  * configuration and preset
11086  */
11087 static const char *alc262_models[ALC262_MODEL_LAST] = {
11088         [ALC262_BASIC]          = "basic",
11089         [ALC262_HIPPO]          = "hippo",
11090         [ALC262_HIPPO_1]        = "hippo_1",
11091         [ALC262_FUJITSU]        = "fujitsu",
11092         [ALC262_HP_BPC]         = "hp-bpc",
11093         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
11094         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
11095         [ALC262_HP_RP5700]      = "hp-rp5700",
11096         [ALC262_BENQ_ED8]       = "benq",
11097         [ALC262_BENQ_T31]       = "benq-t31",
11098         [ALC262_SONY_ASSAMD]    = "sony-assamd",
11099         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
11100         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
11101         [ALC262_ULTRA]          = "ultra",
11102         [ALC262_LENOVO_3000]    = "lenovo-3000",
11103         [ALC262_NEC]            = "nec",
11104         [ALC262_TYAN]           = "tyan",
11105         [ALC262_AUTO]           = "auto",
11106 };
11107
11108 static struct snd_pci_quirk alc262_cfg_tbl[] = {
11109         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
11110         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
11111         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
11112                            ALC262_HP_BPC),
11113         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
11114                            ALC262_HP_BPC),
11115         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
11116                            ALC262_HP_BPC),
11117         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
11118         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
11119         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
11120         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
11121         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
11122         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
11123         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
11124         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
11125         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
11126         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
11127         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
11128         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
11129                       ALC262_HP_TC_T5735),
11130         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
11131         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11132         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
11133         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11134         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
11135         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
11136         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
11137                            ALC262_SONY_ASSAMD),
11138         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
11139                       ALC262_TOSHIBA_RX1),
11140         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
11141         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
11142         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
11143         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
11144         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
11145                            ALC262_ULTRA),
11146         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
11147         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
11148         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
11149         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
11150         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
11151         {}
11152 };
11153
11154 static struct alc_config_preset alc262_presets[] = {
11155         [ALC262_BASIC] = {
11156                 .mixers = { alc262_base_mixer },
11157                 .init_verbs = { alc262_init_verbs },
11158                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11159                 .dac_nids = alc262_dac_nids,
11160                 .hp_nid = 0x03,
11161                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11162                 .channel_mode = alc262_modes,
11163                 .input_mux = &alc262_capture_source,
11164         },
11165         [ALC262_HIPPO] = {
11166                 .mixers = { alc262_hippo_mixer },
11167                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
11168                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11169                 .dac_nids = alc262_dac_nids,
11170                 .hp_nid = 0x03,
11171                 .dig_out_nid = ALC262_DIGOUT_NID,
11172                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11173                 .channel_mode = alc262_modes,
11174                 .input_mux = &alc262_capture_source,
11175                 .unsol_event = alc262_hippo_unsol_event,
11176                 .init_hook = alc262_hippo_init_hook,
11177         },
11178         [ALC262_HIPPO_1] = {
11179                 .mixers = { alc262_hippo1_mixer },
11180                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
11181                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11182                 .dac_nids = alc262_dac_nids,
11183                 .hp_nid = 0x02,
11184                 .dig_out_nid = ALC262_DIGOUT_NID,
11185                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11186                 .channel_mode = alc262_modes,
11187                 .input_mux = &alc262_capture_source,
11188                 .unsol_event = alc262_hippo_unsol_event,
11189                 .init_hook = alc262_hippo1_init_hook,
11190         },
11191         [ALC262_FUJITSU] = {
11192                 .mixers = { alc262_fujitsu_mixer },
11193                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11194                                 alc262_fujitsu_unsol_verbs },
11195                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11196                 .dac_nids = alc262_dac_nids,
11197                 .hp_nid = 0x03,
11198                 .dig_out_nid = ALC262_DIGOUT_NID,
11199                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11200                 .channel_mode = alc262_modes,
11201                 .input_mux = &alc262_fujitsu_capture_source,
11202                 .unsol_event = alc262_fujitsu_unsol_event,
11203                 .init_hook = alc262_fujitsu_init_hook,
11204         },
11205         [ALC262_HP_BPC] = {
11206                 .mixers = { alc262_HP_BPC_mixer },
11207                 .init_verbs = { alc262_HP_BPC_init_verbs },
11208                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11209                 .dac_nids = alc262_dac_nids,
11210                 .hp_nid = 0x03,
11211                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11212                 .channel_mode = alc262_modes,
11213                 .input_mux = &alc262_HP_capture_source,
11214                 .unsol_event = alc262_hp_bpc_unsol_event,
11215                 .init_hook = alc262_hp_bpc_automute,
11216         },
11217         [ALC262_HP_BPC_D7000_WF] = {
11218                 .mixers = { alc262_HP_BPC_WildWest_mixer },
11219                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11220                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11221                 .dac_nids = alc262_dac_nids,
11222                 .hp_nid = 0x03,
11223                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11224                 .channel_mode = alc262_modes,
11225                 .input_mux = &alc262_HP_D7000_capture_source,
11226                 .unsol_event = alc262_hp_wildwest_unsol_event,
11227                 .init_hook = alc262_hp_wildwest_automute,
11228         },
11229         [ALC262_HP_BPC_D7000_WL] = {
11230                 .mixers = { alc262_HP_BPC_WildWest_mixer,
11231                             alc262_HP_BPC_WildWest_option_mixer },
11232                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11233                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11234                 .dac_nids = alc262_dac_nids,
11235                 .hp_nid = 0x03,
11236                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11237                 .channel_mode = alc262_modes,
11238                 .input_mux = &alc262_HP_D7000_capture_source,
11239                 .unsol_event = alc262_hp_wildwest_unsol_event,
11240                 .init_hook = alc262_hp_wildwest_automute,
11241         },
11242         [ALC262_HP_TC_T5735] = {
11243                 .mixers = { alc262_hp_t5735_mixer },
11244                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
11245                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11246                 .dac_nids = alc262_dac_nids,
11247                 .hp_nid = 0x03,
11248                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11249                 .channel_mode = alc262_modes,
11250                 .input_mux = &alc262_capture_source,
11251                 .unsol_event = alc_automute_amp_unsol_event,
11252                 .init_hook = alc262_hp_t5735_init_hook,
11253         },
11254         [ALC262_HP_RP5700] = {
11255                 .mixers = { alc262_hp_rp5700_mixer },
11256                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11257                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11258                 .dac_nids = alc262_dac_nids,
11259                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11260                 .channel_mode = alc262_modes,
11261                 .input_mux = &alc262_hp_rp5700_capture_source,
11262         },
11263         [ALC262_BENQ_ED8] = {
11264                 .mixers = { alc262_base_mixer },
11265                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11266                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11267                 .dac_nids = alc262_dac_nids,
11268                 .hp_nid = 0x03,
11269                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11270                 .channel_mode = alc262_modes,
11271                 .input_mux = &alc262_capture_source,
11272         },
11273         [ALC262_SONY_ASSAMD] = {
11274                 .mixers = { alc262_sony_mixer },
11275                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11276                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11277                 .dac_nids = alc262_dac_nids,
11278                 .hp_nid = 0x02,
11279                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11280                 .channel_mode = alc262_modes,
11281                 .input_mux = &alc262_capture_source,
11282                 .unsol_event = alc262_hippo_unsol_event,
11283                 .init_hook = alc262_hippo_init_hook,
11284         },
11285         [ALC262_BENQ_T31] = {
11286                 .mixers = { alc262_benq_t31_mixer },
11287                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
11288                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11289                 .dac_nids = alc262_dac_nids,
11290                 .hp_nid = 0x03,
11291                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11292                 .channel_mode = alc262_modes,
11293                 .input_mux = &alc262_capture_source,
11294                 .unsol_event = alc262_hippo_unsol_event,
11295                 .init_hook = alc262_hippo_init_hook,
11296         },
11297         [ALC262_ULTRA] = {
11298                 .mixers = { alc262_ultra_mixer },
11299                 .cap_mixer = alc262_ultra_capture_mixer,
11300                 .init_verbs = { alc262_ultra_verbs },
11301                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11302                 .dac_nids = alc262_dac_nids,
11303                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11304                 .channel_mode = alc262_modes,
11305                 .input_mux = &alc262_ultra_capture_source,
11306                 .adc_nids = alc262_adc_nids, /* ADC0 */
11307                 .capsrc_nids = alc262_capsrc_nids,
11308                 .num_adc_nids = 1, /* single ADC */
11309                 .unsol_event = alc262_ultra_unsol_event,
11310                 .init_hook = alc262_ultra_automute,
11311         },
11312         [ALC262_LENOVO_3000] = {
11313                 .mixers = { alc262_lenovo_3000_mixer },
11314                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11315                                 alc262_lenovo_3000_unsol_verbs },
11316                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11317                 .dac_nids = alc262_dac_nids,
11318                 .hp_nid = 0x03,
11319                 .dig_out_nid = ALC262_DIGOUT_NID,
11320                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11321                 .channel_mode = alc262_modes,
11322                 .input_mux = &alc262_fujitsu_capture_source,
11323                 .unsol_event = alc262_lenovo_3000_unsol_event,
11324         },
11325         [ALC262_NEC] = {
11326                 .mixers = { alc262_nec_mixer },
11327                 .init_verbs = { alc262_nec_verbs },
11328                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11329                 .dac_nids = alc262_dac_nids,
11330                 .hp_nid = 0x03,
11331                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11332                 .channel_mode = alc262_modes,
11333                 .input_mux = &alc262_capture_source,
11334         },
11335         [ALC262_TOSHIBA_S06] = {
11336                 .mixers = { alc262_toshiba_s06_mixer },
11337                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11338                                                         alc262_eapd_verbs },
11339                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11340                 .capsrc_nids = alc262_dmic_capsrc_nids,
11341                 .dac_nids = alc262_dac_nids,
11342                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11343                 .num_adc_nids = 1, /* single ADC */
11344                 .dig_out_nid = ALC262_DIGOUT_NID,
11345                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11346                 .channel_mode = alc262_modes,
11347                 .input_mux = &alc262_dmic_capture_source,
11348                 .unsol_event = alc262_toshiba_s06_unsol_event,
11349                 .init_hook = alc262_toshiba_s06_init_hook,
11350         },
11351         [ALC262_TOSHIBA_RX1] = {
11352                 .mixers = { alc262_toshiba_rx1_mixer },
11353                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11354                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11355                 .dac_nids = alc262_dac_nids,
11356                 .hp_nid = 0x03,
11357                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11358                 .channel_mode = alc262_modes,
11359                 .input_mux = &alc262_capture_source,
11360                 .unsol_event = alc262_hippo_unsol_event,
11361                 .init_hook = alc262_hippo_init_hook,
11362         },
11363         [ALC262_TYAN] = {
11364                 .mixers = { alc262_tyan_mixer },
11365                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11366                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11367                 .dac_nids = alc262_dac_nids,
11368                 .hp_nid = 0x02,
11369                 .dig_out_nid = ALC262_DIGOUT_NID,
11370                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11371                 .channel_mode = alc262_modes,
11372                 .input_mux = &alc262_capture_source,
11373                 .unsol_event = alc_automute_amp_unsol_event,
11374                 .init_hook = alc262_tyan_init_hook,
11375         },
11376 };
11377
11378 static int patch_alc262(struct hda_codec *codec)
11379 {
11380         struct alc_spec *spec;
11381         int board_config;
11382         int err;
11383
11384         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11385         if (spec == NULL)
11386                 return -ENOMEM;
11387
11388         codec->spec = spec;
11389 #if 0
11390         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11391          * under-run
11392          */
11393         {
11394         int tmp;
11395         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11396         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11397         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11398         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11399         }
11400 #endif
11401
11402         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11403
11404         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11405                                                   alc262_models,
11406                                                   alc262_cfg_tbl);
11407
11408         if (board_config < 0) {
11409                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
11410                        "trying auto-probe from BIOS...\n", codec->chip_name);
11411                 board_config = ALC262_AUTO;
11412         }
11413
11414         if (board_config == ALC262_AUTO) {
11415                 /* automatic parse from the BIOS config */
11416                 err = alc262_parse_auto_config(codec);
11417                 if (err < 0) {
11418                         alc_free(codec);
11419                         return err;
11420                 } else if (!err) {
11421                         printk(KERN_INFO
11422                                "hda_codec: Cannot set up configuration "
11423                                "from BIOS.  Using base mode...\n");
11424                         board_config = ALC262_BASIC;
11425                 }
11426         }
11427
11428         if (!spec->no_analog) {
11429                 err = snd_hda_attach_beep_device(codec, 0x1);
11430                 if (err < 0) {
11431                         alc_free(codec);
11432                         return err;
11433                 }
11434         }
11435
11436         if (board_config != ALC262_AUTO)
11437                 setup_preset(spec, &alc262_presets[board_config]);
11438
11439         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11440         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11441
11442         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11443         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11444
11445         if (!spec->adc_nids && spec->input_mux) {
11446                 int i;
11447                 /* check whether the digital-mic has to be supported */
11448                 for (i = 0; i < spec->input_mux->num_items; i++) {
11449                         if (spec->input_mux->items[i].index >= 9)
11450                                 break;
11451                 }
11452                 if (i < spec->input_mux->num_items) {
11453                         /* use only ADC0 */
11454                         spec->adc_nids = alc262_dmic_adc_nids;
11455                         spec->num_adc_nids = 1;
11456                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
11457                 } else {
11458                         /* all analog inputs */
11459                         /* check whether NID 0x07 is valid */
11460                         unsigned int wcap = get_wcaps(codec, 0x07);
11461
11462                         /* get type */
11463                         wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11464                         if (wcap != AC_WID_AUD_IN) {
11465                                 spec->adc_nids = alc262_adc_nids_alt;
11466                                 spec->num_adc_nids =
11467                                         ARRAY_SIZE(alc262_adc_nids_alt);
11468                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
11469                         } else {
11470                                 spec->adc_nids = alc262_adc_nids;
11471                                 spec->num_adc_nids =
11472                                         ARRAY_SIZE(alc262_adc_nids);
11473                                 spec->capsrc_nids = alc262_capsrc_nids;
11474                         }
11475                 }
11476         }
11477         if (!spec->cap_mixer && !spec->no_analog)
11478                 set_capture_mixer(spec);
11479         if (!spec->no_analog)
11480                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11481
11482         spec->vmaster_nid = 0x0c;
11483
11484         codec->patch_ops = alc_patch_ops;
11485         if (board_config == ALC262_AUTO)
11486                 spec->init_hook = alc262_auto_init;
11487 #ifdef CONFIG_SND_HDA_POWER_SAVE
11488         if (!spec->loopback.amplist)
11489                 spec->loopback.amplist = alc262_loopbacks;
11490 #endif
11491         codec->proc_widget_hook = print_realtek_coef;
11492
11493         return 0;
11494 }
11495
11496 /*
11497  *  ALC268 channel source setting (2 channel)
11498  */
11499 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
11500 #define alc268_modes            alc260_modes
11501
11502 static hda_nid_t alc268_dac_nids[2] = {
11503         /* front, hp */
11504         0x02, 0x03
11505 };
11506
11507 static hda_nid_t alc268_adc_nids[2] = {
11508         /* ADC0-1 */
11509         0x08, 0x07
11510 };
11511
11512 static hda_nid_t alc268_adc_nids_alt[1] = {
11513         /* ADC0 */
11514         0x08
11515 };
11516
11517 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11518
11519 static struct snd_kcontrol_new alc268_base_mixer[] = {
11520         /* output mixer control */
11521         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11522         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11523         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11524         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11525         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11526         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11527         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11528         { }
11529 };
11530
11531 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
11532         /* output mixer control */
11533         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11534         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11535         ALC262_HIPPO_MASTER_SWITCH,
11536         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11537         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11538         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11539         { }
11540 };
11541
11542 /* bind Beep switches of both NID 0x0f and 0x10 */
11543 static struct hda_bind_ctls alc268_bind_beep_sw = {
11544         .ops = &snd_hda_bind_sw,
11545         .values = {
11546                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
11547                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
11548                 0
11549         },
11550 };
11551
11552 static struct snd_kcontrol_new alc268_beep_mixer[] = {
11553         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
11554         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
11555         { }
11556 };
11557
11558 static struct hda_verb alc268_eapd_verbs[] = {
11559         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11560         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11561         { }
11562 };
11563
11564 /* Toshiba specific */
11565 static struct hda_verb alc268_toshiba_verbs[] = {
11566         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11567         { } /* end */
11568 };
11569
11570 static struct hda_input_mux alc268_acer_lc_capture_source = {
11571         .num_items = 2,
11572         .items = {
11573                 { "i-Mic", 0x6 },
11574                 { "E-Mic", 0x0 },
11575         },
11576 };
11577
11578 /* Acer specific */
11579 /* bind volumes of both NID 0x02 and 0x03 */
11580 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
11581         .ops = &snd_hda_bind_vol,
11582         .values = {
11583                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11584                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11585                 0
11586         },
11587 };
11588
11589 /* mute/unmute internal speaker according to the hp jack and mute state */
11590 static void alc268_acer_automute(struct hda_codec *codec, int force)
11591 {
11592         struct alc_spec *spec = codec->spec;
11593         unsigned int mute;
11594
11595         if (force || !spec->sense_updated) {
11596                 unsigned int present;
11597                 present = snd_hda_codec_read(codec, 0x14, 0,
11598                                          AC_VERB_GET_PIN_SENSE, 0);
11599                 spec->jack_present = (present & 0x80000000) != 0;
11600                 spec->sense_updated = 1;
11601         }
11602         if (spec->jack_present)
11603                 mute = HDA_AMP_MUTE; /* mute internal speaker */
11604         else /* unmute internal speaker if necessary */
11605                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11606         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11607                                  HDA_AMP_MUTE, mute);
11608 }
11609
11610
11611 /* bind hp and internal speaker mute (with plug check) */
11612 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
11613                                      struct snd_ctl_elem_value *ucontrol)
11614 {
11615         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11616         long *valp = ucontrol->value.integer.value;
11617         int change;
11618
11619         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11620         if (change)
11621                 alc268_acer_automute(codec, 0);
11622         return change;
11623 }
11624
11625 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
11626         /* output mixer control */
11627         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11628         {
11629                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11630                 .name = "Master Playback Switch",
11631                 .info = snd_hda_mixer_amp_switch_info,
11632                 .get = snd_hda_mixer_amp_switch_get,
11633                 .put = alc268_acer_master_sw_put,
11634                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11635         },
11636         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
11637         { }
11638 };
11639
11640 static struct snd_kcontrol_new alc268_acer_mixer[] = {
11641         /* output mixer control */
11642         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11643         {
11644                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11645                 .name = "Master Playback Switch",
11646                 .info = snd_hda_mixer_amp_switch_info,
11647                 .get = snd_hda_mixer_amp_switch_get,
11648                 .put = alc268_acer_master_sw_put,
11649                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11650         },
11651         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11652         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11653         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11654         { }
11655 };
11656
11657 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
11658         /* output mixer control */
11659         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11660         {
11661                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11662                 .name = "Master Playback Switch",
11663                 .info = snd_hda_mixer_amp_switch_info,
11664                 .get = snd_hda_mixer_amp_switch_get,
11665                 .put = alc268_acer_master_sw_put,
11666                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11667         },
11668         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11669         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11670         { }
11671 };
11672
11673 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
11674         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11675         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11676         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11677         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11678         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
11679         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
11680         { }
11681 };
11682
11683 static struct hda_verb alc268_acer_verbs[] = {
11684         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
11685         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11686         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11687         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11688         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11689         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11690         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11691         { }
11692 };
11693
11694 /* unsolicited event for HP jack sensing */
11695 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
11696 #define alc268_toshiba_init_hook        alc262_hippo_init_hook
11697
11698 static void alc268_acer_unsol_event(struct hda_codec *codec,
11699                                        unsigned int res)
11700 {
11701         if ((res >> 26) != ALC880_HP_EVENT)
11702                 return;
11703         alc268_acer_automute(codec, 1);
11704 }
11705
11706 static void alc268_acer_init_hook(struct hda_codec *codec)
11707 {
11708         alc268_acer_automute(codec, 1);
11709 }
11710
11711 /* toggle speaker-output according to the hp-jack state */
11712 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
11713 {
11714         unsigned int present;
11715         unsigned char bits;
11716
11717         present = snd_hda_codec_read(codec, 0x15, 0,
11718                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11719         bits = present ? AMP_IN_MUTE(0) : 0;
11720         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
11721                                 AMP_IN_MUTE(0), bits);
11722         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
11723                                 AMP_IN_MUTE(0), bits);
11724 }
11725
11726
11727 static void alc268_acer_mic_automute(struct hda_codec *codec)
11728 {
11729         unsigned int present;
11730
11731         present = snd_hda_codec_read(codec, 0x18, 0,
11732                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11733         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11734                             present ? 0x0 : 0x6);
11735 }
11736
11737 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
11738                                     unsigned int res)
11739 {
11740         if ((res >> 26) == ALC880_HP_EVENT)
11741                 alc268_aspire_one_speaker_automute(codec);
11742         if ((res >> 26) == ALC880_MIC_EVENT)
11743                 alc268_acer_mic_automute(codec);
11744 }
11745
11746 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
11747 {
11748         alc268_aspire_one_speaker_automute(codec);
11749         alc268_acer_mic_automute(codec);
11750 }
11751
11752 static struct snd_kcontrol_new alc268_dell_mixer[] = {
11753         /* output mixer control */
11754         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11755         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11756         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11757         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11758         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11759         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11760         { }
11761 };
11762
11763 static struct hda_verb alc268_dell_verbs[] = {
11764         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11765         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11766         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11767         { }
11768 };
11769
11770 /* mute/unmute internal speaker according to the hp jack and mute state */
11771 static void alc268_dell_init_hook(struct hda_codec *codec)
11772 {
11773         struct alc_spec *spec = codec->spec;
11774
11775         spec->autocfg.hp_pins[0] = 0x15;
11776         spec->autocfg.speaker_pins[0] = 0x14;
11777         alc_automute_pin(codec);
11778 }
11779
11780 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
11781         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11782         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11783         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11784         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11785         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11786         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
11787         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
11788         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11789         { }
11790 };
11791
11792 static struct hda_verb alc267_quanta_il1_verbs[] = {
11793         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11794         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11795         { }
11796 };
11797
11798 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11799 {
11800         unsigned int present;
11801
11802         present = snd_hda_codec_read(codec, 0x18, 0,
11803                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11804         snd_hda_codec_write(codec, 0x23, 0,
11805                             AC_VERB_SET_CONNECT_SEL,
11806                             present ? 0x00 : 0x01);
11807 }
11808
11809 static void alc267_quanta_il1_init_hook(struct hda_codec *codec)
11810 {
11811         struct alc_spec *spec = codec->spec;
11812
11813         spec->autocfg.hp_pins[0] = 0x15;
11814         spec->autocfg.speaker_pins[0] = 0x14;
11815         alc_automute_pin(codec);
11816         alc267_quanta_il1_mic_automute(codec);
11817 }
11818
11819 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11820                                            unsigned int res)
11821 {
11822         switch (res >> 26) {
11823         case ALC880_MIC_EVENT:
11824                 alc267_quanta_il1_mic_automute(codec);
11825                 break;
11826         default:
11827                 alc_sku_unsol_event(codec, res);
11828                 break;
11829         }
11830 }
11831
11832 /*
11833  * generic initialization of ADC, input mixers and output mixers
11834  */
11835 static struct hda_verb alc268_base_init_verbs[] = {
11836         /* Unmute DAC0-1 and set vol = 0 */
11837         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11838         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11839
11840         /*
11841          * Set up output mixers (0x0c - 0x0e)
11842          */
11843         /* set vol=0 to output mixers */
11844         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11845         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11846
11847         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11848         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11849
11850         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11851         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11852         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11853         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11854         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11855         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11856         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11857         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11858
11859         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11860         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11861         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11862         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11863         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11864
11865         /* set PCBEEP vol = 0, mute connections */
11866         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11867         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11868         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11869
11870         /* Unmute Selector 23h,24h and set the default input to mic-in */
11871
11872         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11873         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11874         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11875         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11876
11877         { }
11878 };
11879
11880 /*
11881  * generic initialization of ADC, input mixers and output mixers
11882  */
11883 static struct hda_verb alc268_volume_init_verbs[] = {
11884         /* set output DAC */
11885         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11886         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11887
11888         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11889         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11890         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11891         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11892         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11893
11894         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11895         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11896         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11897
11898         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11899         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11900
11901         /* set PCBEEP vol = 0, mute connections */
11902         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11903         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11904         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11905
11906         { }
11907 };
11908
11909 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11910         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11911         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11912         {
11913                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11914                 /* The multiple "Capture Source" controls confuse alsamixer
11915                  * So call somewhat different..
11916                  */
11917                 /* .name = "Capture Source", */
11918                 .name = "Input Source",
11919                 .count = 1,
11920                 .info = alc_mux_enum_info,
11921                 .get = alc_mux_enum_get,
11922                 .put = alc_mux_enum_put,
11923         },
11924         { } /* end */
11925 };
11926
11927 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11928         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11929         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11930         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11931         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11932         {
11933                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11934                 /* The multiple "Capture Source" controls confuse alsamixer
11935                  * So call somewhat different..
11936                  */
11937                 /* .name = "Capture Source", */
11938                 .name = "Input Source",
11939                 .count = 2,
11940                 .info = alc_mux_enum_info,
11941                 .get = alc_mux_enum_get,
11942                 .put = alc_mux_enum_put,
11943         },
11944         { } /* end */
11945 };
11946
11947 static struct hda_input_mux alc268_capture_source = {
11948         .num_items = 4,
11949         .items = {
11950                 { "Mic", 0x0 },
11951                 { "Front Mic", 0x1 },
11952                 { "Line", 0x2 },
11953                 { "CD", 0x3 },
11954         },
11955 };
11956
11957 static struct hda_input_mux alc268_acer_capture_source = {
11958         .num_items = 3,
11959         .items = {
11960                 { "Mic", 0x0 },
11961                 { "Internal Mic", 0x1 },
11962                 { "Line", 0x2 },
11963         },
11964 };
11965
11966 static struct hda_input_mux alc268_acer_dmic_capture_source = {
11967         .num_items = 3,
11968         .items = {
11969                 { "Mic", 0x0 },
11970                 { "Internal Mic", 0x6 },
11971                 { "Line", 0x2 },
11972         },
11973 };
11974
11975 #ifdef CONFIG_SND_DEBUG
11976 static struct snd_kcontrol_new alc268_test_mixer[] = {
11977         /* Volume widgets */
11978         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11979         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11980         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11981         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11982         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11983         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11984         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11985         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11986         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11987         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11988         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11989         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11990         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11991         /* The below appears problematic on some hardwares */
11992         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11993         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11994         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11995         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11996         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11997
11998         /* Modes for retasking pin widgets */
11999         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
12000         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
12001         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
12002         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
12003
12004         /* Controls for GPIO pins, assuming they are configured as outputs */
12005         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
12006         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
12007         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
12008         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
12009
12010         /* Switches to allow the digital SPDIF output pin to be enabled.
12011          * The ALC268 does not have an SPDIF input.
12012          */
12013         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
12014
12015         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
12016          * this output to turn on an external amplifier.
12017          */
12018         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
12019         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
12020
12021         { } /* end */
12022 };
12023 #endif
12024
12025 /* create input playback/capture controls for the given pin */
12026 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
12027                                     const char *ctlname, int idx)
12028 {
12029         char name[32];
12030         hda_nid_t dac;
12031         int err;
12032
12033         sprintf(name, "%s Playback Volume", ctlname);
12034         switch (nid) {
12035         case 0x14:
12036         case 0x16:
12037                 dac = 0x02;
12038                 break;
12039         case 0x15:
12040                 dac = 0x03;
12041                 break;
12042         default:
12043                 return 0;
12044         }
12045         if (spec->multiout.dac_nids[0] != dac &&
12046             spec->multiout.dac_nids[1] != dac) {
12047                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
12048                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
12049                                                       HDA_OUTPUT));
12050                 if (err < 0)
12051                         return err;
12052                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
12053         }
12054
12055         sprintf(name, "%s Playback Switch", ctlname);
12056         if (nid != 0x16)
12057                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
12058                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
12059         else /* mono */
12060                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
12061                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
12062         if (err < 0)
12063                 return err;
12064         return 0;
12065 }
12066
12067 /* add playback controls from the parsed DAC table */
12068 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
12069                                              const struct auto_pin_cfg *cfg)
12070 {
12071         hda_nid_t nid;
12072         int err;
12073
12074         spec->multiout.dac_nids = spec->private_dac_nids;
12075
12076         nid = cfg->line_out_pins[0];
12077         if (nid) {
12078                 const char *name;
12079                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12080                         name = "Speaker";
12081                 else
12082                         name = "Front";
12083                 err = alc268_new_analog_output(spec, nid, name, 0);
12084                 if (err < 0)
12085                         return err;
12086         }
12087
12088         nid = cfg->speaker_pins[0];
12089         if (nid == 0x1d) {
12090                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12091                                   "Speaker Playback Volume",
12092                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
12093                 if (err < 0)
12094                         return err;
12095         } else {
12096                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
12097                 if (err < 0)
12098                         return err;
12099         }
12100         nid = cfg->hp_pins[0];
12101         if (nid) {
12102                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
12103                 if (err < 0)
12104                         return err;
12105         }
12106
12107         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
12108         if (nid == 0x16) {
12109                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12110                                   "Mono Playback Switch",
12111                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
12112                 if (err < 0)
12113                         return err;
12114         }
12115         return 0;
12116 }
12117
12118 /* create playback/capture controls for input pins */
12119 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
12120                                                 const struct auto_pin_cfg *cfg)
12121 {
12122         struct hda_input_mux *imux = &spec->private_imux[0];
12123         int i, idx1;
12124
12125         for (i = 0; i < AUTO_PIN_LAST; i++) {
12126                 switch(cfg->input_pins[i]) {
12127                 case 0x18:
12128                         idx1 = 0;       /* Mic 1 */
12129                         break;
12130                 case 0x19:
12131                         idx1 = 1;       /* Mic 2 */
12132                         break;
12133                 case 0x1a:
12134                         idx1 = 2;       /* Line In */
12135                         break;
12136                 case 0x1c:
12137                         idx1 = 3;       /* CD */
12138                         break;
12139                 case 0x12:
12140                 case 0x13:
12141                         idx1 = 6;       /* digital mics */
12142                         break;
12143                 default:
12144                         continue;
12145                 }
12146                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
12147                 imux->items[imux->num_items].index = idx1;
12148                 imux->num_items++;
12149         }
12150         return 0;
12151 }
12152
12153 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
12154 {
12155         struct alc_spec *spec = codec->spec;
12156         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
12157         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
12158         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
12159         unsigned int    dac_vol1, dac_vol2;
12160
12161         if (speaker_nid) {
12162                 snd_hda_codec_write(codec, speaker_nid, 0,
12163                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
12164                 snd_hda_codec_write(codec, 0x0f, 0,
12165                                     AC_VERB_SET_AMP_GAIN_MUTE,
12166                                     AMP_IN_UNMUTE(1));
12167                 snd_hda_codec_write(codec, 0x10, 0,
12168                                     AC_VERB_SET_AMP_GAIN_MUTE,
12169                                     AMP_IN_UNMUTE(1));
12170         } else {
12171                 snd_hda_codec_write(codec, 0x0f, 0,
12172                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12173                 snd_hda_codec_write(codec, 0x10, 0,
12174                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12175         }
12176
12177         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
12178         if (line_nid == 0x14)
12179                 dac_vol2 = AMP_OUT_ZERO;
12180         else if (line_nid == 0x15)
12181                 dac_vol1 = AMP_OUT_ZERO;
12182         if (hp_nid == 0x14)
12183                 dac_vol2 = AMP_OUT_ZERO;
12184         else if (hp_nid == 0x15)
12185                 dac_vol1 = AMP_OUT_ZERO;
12186         if (line_nid != 0x16 || hp_nid != 0x16 ||
12187             spec->autocfg.line_out_pins[1] != 0x16 ||
12188             spec->autocfg.line_out_pins[2] != 0x16)
12189                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
12190
12191         snd_hda_codec_write(codec, 0x02, 0,
12192                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
12193         snd_hda_codec_write(codec, 0x03, 0,
12194                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
12195 }
12196
12197 /* pcm configuration: identical with ALC880 */
12198 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
12199 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
12200 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
12201 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
12202
12203 /*
12204  * BIOS auto configuration
12205  */
12206 static int alc268_parse_auto_config(struct hda_codec *codec)
12207 {
12208         struct alc_spec *spec = codec->spec;
12209         int err;
12210         static hda_nid_t alc268_ignore[] = { 0 };
12211
12212         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12213                                            alc268_ignore);
12214         if (err < 0)
12215                 return err;
12216         if (!spec->autocfg.line_outs) {
12217                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12218                         spec->multiout.max_channels = 2;
12219                         spec->no_analog = 1;
12220                         goto dig_only;
12221                 }
12222                 return 0; /* can't find valid BIOS pin config */
12223         }
12224         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
12225         if (err < 0)
12226                 return err;
12227         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
12228         if (err < 0)
12229                 return err;
12230
12231         spec->multiout.max_channels = 2;
12232
12233  dig_only:
12234         /* digital only support output */
12235         if (spec->autocfg.dig_outs) {
12236                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
12237                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
12238         }
12239         if (spec->kctls.list)
12240                 add_mixer(spec, spec->kctls.list);
12241
12242         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
12243                 add_mixer(spec, alc268_beep_mixer);
12244
12245         add_verb(spec, alc268_volume_init_verbs);
12246         spec->num_mux_defs = 1;
12247         spec->input_mux = &spec->private_imux[0];
12248
12249         err = alc_auto_add_mic_boost(codec);
12250         if (err < 0)
12251                 return err;
12252
12253         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
12254
12255         return 1;
12256 }
12257
12258 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
12259 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
12260 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
12261
12262 /* init callback for auto-configuration model -- overriding the default init */
12263 static void alc268_auto_init(struct hda_codec *codec)
12264 {
12265         struct alc_spec *spec = codec->spec;
12266         alc268_auto_init_multi_out(codec);
12267         alc268_auto_init_hp_out(codec);
12268         alc268_auto_init_mono_speaker_out(codec);
12269         alc268_auto_init_analog_input(codec);
12270         if (spec->unsol_event)
12271                 alc_inithook(codec);
12272 }
12273
12274 /*
12275  * configuration and preset
12276  */
12277 static const char *alc268_models[ALC268_MODEL_LAST] = {
12278         [ALC267_QUANTA_IL1]     = "quanta-il1",
12279         [ALC268_3ST]            = "3stack",
12280         [ALC268_TOSHIBA]        = "toshiba",
12281         [ALC268_ACER]           = "acer",
12282         [ALC268_ACER_DMIC]      = "acer-dmic",
12283         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
12284         [ALC268_DELL]           = "dell",
12285         [ALC268_ZEPTO]          = "zepto",
12286 #ifdef CONFIG_SND_DEBUG
12287         [ALC268_TEST]           = "test",
12288 #endif
12289         [ALC268_AUTO]           = "auto",
12290 };
12291
12292 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12293         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12294         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12295         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12296         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12297         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12298         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12299                                                 ALC268_ACER_ASPIRE_ONE),
12300         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12301         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
12302         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
12303                            ALC268_TOSHIBA),
12304         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12305         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12306         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
12307                            ALC268_TOSHIBA),
12308         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12309         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12310         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12311         SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
12312         {}
12313 };
12314
12315 static struct alc_config_preset alc268_presets[] = {
12316         [ALC267_QUANTA_IL1] = {
12317                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
12318                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12319                                 alc267_quanta_il1_verbs },
12320                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12321                 .dac_nids = alc268_dac_nids,
12322                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12323                 .adc_nids = alc268_adc_nids_alt,
12324                 .hp_nid = 0x03,
12325                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12326                 .channel_mode = alc268_modes,
12327                 .input_mux = &alc268_capture_source,
12328                 .unsol_event = alc267_quanta_il1_unsol_event,
12329                 .init_hook = alc267_quanta_il1_init_hook,
12330         },
12331         [ALC268_3ST] = {
12332                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12333                             alc268_beep_mixer },
12334                 .init_verbs = { alc268_base_init_verbs },
12335                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12336                 .dac_nids = alc268_dac_nids,
12337                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12338                 .adc_nids = alc268_adc_nids_alt,
12339                 .capsrc_nids = alc268_capsrc_nids,
12340                 .hp_nid = 0x03,
12341                 .dig_out_nid = ALC268_DIGOUT_NID,
12342                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12343                 .channel_mode = alc268_modes,
12344                 .input_mux = &alc268_capture_source,
12345         },
12346         [ALC268_TOSHIBA] = {
12347                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
12348                             alc268_beep_mixer },
12349                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12350                                 alc268_toshiba_verbs },
12351                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12352                 .dac_nids = alc268_dac_nids,
12353                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12354                 .adc_nids = alc268_adc_nids_alt,
12355                 .capsrc_nids = alc268_capsrc_nids,
12356                 .hp_nid = 0x03,
12357                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12358                 .channel_mode = alc268_modes,
12359                 .input_mux = &alc268_capture_source,
12360                 .unsol_event = alc268_toshiba_unsol_event,
12361                 .init_hook = alc268_toshiba_init_hook,
12362         },
12363         [ALC268_ACER] = {
12364                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12365                             alc268_beep_mixer },
12366                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12367                                 alc268_acer_verbs },
12368                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12369                 .dac_nids = alc268_dac_nids,
12370                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12371                 .adc_nids = alc268_adc_nids_alt,
12372                 .capsrc_nids = alc268_capsrc_nids,
12373                 .hp_nid = 0x02,
12374                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12375                 .channel_mode = alc268_modes,
12376                 .input_mux = &alc268_acer_capture_source,
12377                 .unsol_event = alc268_acer_unsol_event,
12378                 .init_hook = alc268_acer_init_hook,
12379         },
12380         [ALC268_ACER_DMIC] = {
12381                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12382                             alc268_beep_mixer },
12383                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12384                                 alc268_acer_verbs },
12385                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12386                 .dac_nids = alc268_dac_nids,
12387                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12388                 .adc_nids = alc268_adc_nids_alt,
12389                 .capsrc_nids = alc268_capsrc_nids,
12390                 .hp_nid = 0x02,
12391                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12392                 .channel_mode = alc268_modes,
12393                 .input_mux = &alc268_acer_dmic_capture_source,
12394                 .unsol_event = alc268_acer_unsol_event,
12395                 .init_hook = alc268_acer_init_hook,
12396         },
12397         [ALC268_ACER_ASPIRE_ONE] = {
12398                 .mixers = { alc268_acer_aspire_one_mixer,
12399                             alc268_beep_mixer,
12400                             alc268_capture_alt_mixer },
12401                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12402                                 alc268_acer_aspire_one_verbs },
12403                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12404                 .dac_nids = alc268_dac_nids,
12405                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12406                 .adc_nids = alc268_adc_nids_alt,
12407                 .capsrc_nids = alc268_capsrc_nids,
12408                 .hp_nid = 0x03,
12409                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12410                 .channel_mode = alc268_modes,
12411                 .input_mux = &alc268_acer_lc_capture_source,
12412                 .unsol_event = alc268_acer_lc_unsol_event,
12413                 .init_hook = alc268_acer_lc_init_hook,
12414         },
12415         [ALC268_DELL] = {
12416                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
12417                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12418                                 alc268_dell_verbs },
12419                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12420                 .dac_nids = alc268_dac_nids,
12421                 .hp_nid = 0x02,
12422                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12423                 .channel_mode = alc268_modes,
12424                 .unsol_event = alc_sku_unsol_event,
12425                 .init_hook = alc268_dell_init_hook,
12426                 .input_mux = &alc268_capture_source,
12427         },
12428         [ALC268_ZEPTO] = {
12429                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12430                             alc268_beep_mixer },
12431                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12432                                 alc268_toshiba_verbs },
12433                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12434                 .dac_nids = alc268_dac_nids,
12435                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12436                 .adc_nids = alc268_adc_nids_alt,
12437                 .capsrc_nids = alc268_capsrc_nids,
12438                 .hp_nid = 0x03,
12439                 .dig_out_nid = ALC268_DIGOUT_NID,
12440                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12441                 .channel_mode = alc268_modes,
12442                 .input_mux = &alc268_capture_source,
12443                 .unsol_event = alc268_toshiba_unsol_event,
12444                 .init_hook = alc268_toshiba_init_hook
12445         },
12446 #ifdef CONFIG_SND_DEBUG
12447         [ALC268_TEST] = {
12448                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
12449                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12450                                 alc268_volume_init_verbs },
12451                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12452                 .dac_nids = alc268_dac_nids,
12453                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12454                 .adc_nids = alc268_adc_nids_alt,
12455                 .capsrc_nids = alc268_capsrc_nids,
12456                 .hp_nid = 0x03,
12457                 .dig_out_nid = ALC268_DIGOUT_NID,
12458                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12459                 .channel_mode = alc268_modes,
12460                 .input_mux = &alc268_capture_source,
12461         },
12462 #endif
12463 };
12464
12465 static int patch_alc268(struct hda_codec *codec)
12466 {
12467         struct alc_spec *spec;
12468         int board_config;
12469         int i, has_beep, err;
12470
12471         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12472         if (spec == NULL)
12473                 return -ENOMEM;
12474
12475         codec->spec = spec;
12476
12477         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12478                                                   alc268_models,
12479                                                   alc268_cfg_tbl);
12480
12481         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12482                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
12483                        "trying auto-probe from BIOS...\n", codec->chip_name);
12484                 board_config = ALC268_AUTO;
12485         }
12486
12487         if (board_config == ALC268_AUTO) {
12488                 /* automatic parse from the BIOS config */
12489                 err = alc268_parse_auto_config(codec);
12490                 if (err < 0) {
12491                         alc_free(codec);
12492                         return err;
12493                 } else if (!err) {
12494                         printk(KERN_INFO
12495                                "hda_codec: Cannot set up configuration "
12496                                "from BIOS.  Using base mode...\n");
12497                         board_config = ALC268_3ST;
12498                 }
12499         }
12500
12501         if (board_config != ALC268_AUTO)
12502                 setup_preset(spec, &alc268_presets[board_config]);
12503
12504         spec->stream_analog_playback = &alc268_pcm_analog_playback;
12505         spec->stream_analog_capture = &alc268_pcm_analog_capture;
12506         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12507
12508         spec->stream_digital_playback = &alc268_pcm_digital_playback;
12509
12510         has_beep = 0;
12511         for (i = 0; i < spec->num_mixers; i++) {
12512                 if (spec->mixers[i] == alc268_beep_mixer) {
12513                         has_beep = 1;
12514                         break;
12515                 }
12516         }
12517
12518         if (has_beep) {
12519                 err = snd_hda_attach_beep_device(codec, 0x1);
12520                 if (err < 0) {
12521                         alc_free(codec);
12522                         return err;
12523                 }
12524                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12525                         /* override the amp caps for beep generator */
12526                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12527                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12528                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12529                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12530                                           (0 << AC_AMPCAP_MUTE_SHIFT));
12531         }
12532
12533         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12534                 /* check whether NID 0x07 is valid */
12535                 unsigned int wcap = get_wcaps(codec, 0x07);
12536                 int i;
12537
12538                 /* get type */
12539                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
12540                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
12541                         spec->adc_nids = alc268_adc_nids_alt;
12542                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
12543                         add_mixer(spec, alc268_capture_alt_mixer);
12544                 } else {
12545                         spec->adc_nids = alc268_adc_nids;
12546                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
12547                         add_mixer(spec, alc268_capture_mixer);
12548                 }
12549                 spec->capsrc_nids = alc268_capsrc_nids;
12550                 /* set default input source */
12551                 for (i = 0; i < spec->num_adc_nids; i++)
12552                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
12553                                 0, AC_VERB_SET_CONNECT_SEL,
12554                                 spec->input_mux->items[0].index);
12555         }
12556
12557         spec->vmaster_nid = 0x02;
12558
12559         codec->patch_ops = alc_patch_ops;
12560         if (board_config == ALC268_AUTO)
12561                 spec->init_hook = alc268_auto_init;
12562
12563         codec->proc_widget_hook = print_realtek_coef;
12564
12565         return 0;
12566 }
12567
12568 /*
12569  *  ALC269 channel source setting (2 channel)
12570  */
12571 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
12572
12573 #define alc269_dac_nids         alc260_dac_nids
12574
12575 static hda_nid_t alc269_adc_nids[1] = {
12576         /* ADC1 */
12577         0x08,
12578 };
12579
12580 static hda_nid_t alc269_capsrc_nids[1] = {
12581         0x23,
12582 };
12583
12584 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
12585  *       not a mux!
12586  */
12587
12588 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
12589         .num_items = 2,
12590         .items = {
12591                 { "i-Mic", 0x5 },
12592                 { "e-Mic", 0x0 },
12593         },
12594 };
12595
12596 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
12597         .num_items = 2,
12598         .items = {
12599                 { "i-Mic", 0x1 },
12600                 { "e-Mic", 0x0 },
12601         },
12602 };
12603
12604 #define alc269_modes            alc260_modes
12605 #define alc269_capture_source   alc880_lg_lw_capture_source
12606
12607 static struct snd_kcontrol_new alc269_base_mixer[] = {
12608         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12609         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12610         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12611         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12612         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12613         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12614         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12615         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12616         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12617         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12618         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12619         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
12620         { } /* end */
12621 };
12622
12623 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
12624         /* output mixer control */
12625         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12626         {
12627                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12628                 .name = "Master Playback Switch",
12629                 .info = snd_hda_mixer_amp_switch_info,
12630                 .get = snd_hda_mixer_amp_switch_get,
12631                 .put = alc268_acer_master_sw_put,
12632                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12633         },
12634         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12635         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12636         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12637         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12638         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12639         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12640         { }
12641 };
12642
12643 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
12644         /* output mixer control */
12645         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12646         {
12647                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12648                 .name = "Master Playback Switch",
12649                 .info = snd_hda_mixer_amp_switch_info,
12650                 .get = snd_hda_mixer_amp_switch_get,
12651                 .put = alc268_acer_master_sw_put,
12652                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12653         },
12654         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12655         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12656         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12657         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12658         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12659         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12660         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
12661         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
12662         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
12663         { }
12664 };
12665
12666 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
12667         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12668         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12669         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12670         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12671         { } /* end */
12672 };
12673
12674 /* capture mixer elements */
12675 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
12676         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12677         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12678         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12679         { } /* end */
12680 };
12681
12682 /* FSC amilo */
12683 #define alc269_fujitsu_mixer    alc269_eeepc_mixer
12684
12685 static struct hda_verb alc269_quanta_fl1_verbs[] = {
12686         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12687         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12688         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12689         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12690         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12691         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12692         { }
12693 };
12694
12695 static struct hda_verb alc269_lifebook_verbs[] = {
12696         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12697         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
12698         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12699         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12700         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12701         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12702         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12703         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12704         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12705         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12706         { }
12707 };
12708
12709 /* toggle speaker-output according to the hp-jack state */
12710 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
12711 {
12712         unsigned int present;
12713         unsigned char bits;
12714
12715         present = snd_hda_codec_read(codec, 0x15, 0,
12716                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12717         bits = present ? AMP_IN_MUTE(0) : 0;
12718         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12719                         AMP_IN_MUTE(0), bits);
12720         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12721                         AMP_IN_MUTE(0), bits);
12722
12723         snd_hda_codec_write(codec, 0x20, 0,
12724                         AC_VERB_SET_COEF_INDEX, 0x0c);
12725         snd_hda_codec_write(codec, 0x20, 0,
12726                         AC_VERB_SET_PROC_COEF, 0x680);
12727
12728         snd_hda_codec_write(codec, 0x20, 0,
12729                         AC_VERB_SET_COEF_INDEX, 0x0c);
12730         snd_hda_codec_write(codec, 0x20, 0,
12731                         AC_VERB_SET_PROC_COEF, 0x480);
12732 }
12733
12734 /* toggle speaker-output according to the hp-jacks state */
12735 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
12736 {
12737         unsigned int present;
12738         unsigned char bits;
12739
12740         /* Check laptop headphone socket */
12741         present = snd_hda_codec_read(codec, 0x15, 0,
12742                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12743
12744         /* Check port replicator headphone socket */
12745         present |= snd_hda_codec_read(codec, 0x1a, 0,
12746                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12747
12748         bits = present ? AMP_IN_MUTE(0) : 0;
12749         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12750                         AMP_IN_MUTE(0), bits);
12751         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12752                         AMP_IN_MUTE(0), bits);
12753
12754         snd_hda_codec_write(codec, 0x20, 0,
12755                         AC_VERB_SET_COEF_INDEX, 0x0c);
12756         snd_hda_codec_write(codec, 0x20, 0,
12757                         AC_VERB_SET_PROC_COEF, 0x680);
12758
12759         snd_hda_codec_write(codec, 0x20, 0,
12760                         AC_VERB_SET_COEF_INDEX, 0x0c);
12761         snd_hda_codec_write(codec, 0x20, 0,
12762                         AC_VERB_SET_PROC_COEF, 0x480);
12763 }
12764
12765 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
12766 {
12767         unsigned int present;
12768
12769         present = snd_hda_codec_read(codec, 0x18, 0,
12770                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12771         snd_hda_codec_write(codec, 0x23, 0,
12772                             AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
12773 }
12774
12775 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
12776 {
12777         unsigned int present_laptop;
12778         unsigned int present_dock;
12779
12780         present_laptop = snd_hda_codec_read(codec, 0x18, 0,
12781                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12782
12783         present_dock = snd_hda_codec_read(codec, 0x1b, 0,
12784                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12785
12786         /* Laptop mic port overrides dock mic port, design decision */
12787         if (present_dock)
12788                 snd_hda_codec_write(codec, 0x23, 0,
12789                                 AC_VERB_SET_CONNECT_SEL, 0x3);
12790         if (present_laptop)
12791                 snd_hda_codec_write(codec, 0x23, 0,
12792                                 AC_VERB_SET_CONNECT_SEL, 0x0);
12793         if (!present_dock && !present_laptop)
12794                 snd_hda_codec_write(codec, 0x23, 0,
12795                                 AC_VERB_SET_CONNECT_SEL, 0x1);
12796 }
12797
12798 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
12799                                     unsigned int res)
12800 {
12801         if ((res >> 26) == ALC880_HP_EVENT)
12802                 alc269_quanta_fl1_speaker_automute(codec);
12803         if ((res >> 26) == ALC880_MIC_EVENT)
12804                 alc269_quanta_fl1_mic_automute(codec);
12805 }
12806
12807 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
12808                                         unsigned int res)
12809 {
12810         if ((res >> 26) == ALC880_HP_EVENT)
12811                 alc269_lifebook_speaker_automute(codec);
12812         if ((res >> 26) == ALC880_MIC_EVENT)
12813                 alc269_lifebook_mic_autoswitch(codec);
12814 }
12815
12816 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
12817 {
12818         alc269_quanta_fl1_speaker_automute(codec);
12819         alc269_quanta_fl1_mic_automute(codec);
12820 }
12821
12822 static void alc269_lifebook_init_hook(struct hda_codec *codec)
12823 {
12824         alc269_lifebook_speaker_automute(codec);
12825         alc269_lifebook_mic_autoswitch(codec);
12826 }
12827
12828 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
12829         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12830         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
12831         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12832         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
12833         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12834         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12835         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12836         {}
12837 };
12838
12839 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
12840         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12841         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
12842         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12843         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
12844         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12845         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12846         {}
12847 };
12848
12849 /* toggle speaker-output according to the hp-jack state */
12850 static void alc269_speaker_automute(struct hda_codec *codec)
12851 {
12852         unsigned int present;
12853         unsigned char bits;
12854
12855         present = snd_hda_codec_read(codec, 0x15, 0,
12856                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12857         bits = present ? AMP_IN_MUTE(0) : 0;
12858         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12859                                 AMP_IN_MUTE(0), bits);
12860         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12861                                 AMP_IN_MUTE(0), bits);
12862 }
12863
12864 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
12865 {
12866         unsigned int present;
12867
12868         present = snd_hda_codec_read(codec, 0x18, 0,
12869                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12870         snd_hda_codec_write(codec, 0x23, 0,
12871                                 AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
12872 }
12873
12874 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
12875 {
12876         unsigned int present;
12877
12878         present = snd_hda_codec_read(codec, 0x18, 0,
12879                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12880         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12881                                 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
12882         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12883                                 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
12884 }
12885
12886 /* unsolicited event for HP jack sensing */
12887 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
12888                                      unsigned int res)
12889 {
12890         if ((res >> 26) == ALC880_HP_EVENT)
12891                 alc269_speaker_automute(codec);
12892
12893         if ((res >> 26) == ALC880_MIC_EVENT)
12894                 alc269_eeepc_dmic_automute(codec);
12895 }
12896
12897 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
12898 {
12899         alc269_speaker_automute(codec);
12900         alc269_eeepc_dmic_automute(codec);
12901 }
12902
12903 /* unsolicited event for HP jack sensing */
12904 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
12905                                      unsigned int res)
12906 {
12907         if ((res >> 26) == ALC880_HP_EVENT)
12908                 alc269_speaker_automute(codec);
12909
12910         if ((res >> 26) == ALC880_MIC_EVENT)
12911                 alc269_eeepc_amic_automute(codec);
12912 }
12913
12914 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12915 {
12916         alc269_speaker_automute(codec);
12917         alc269_eeepc_amic_automute(codec);
12918 }
12919
12920 /*
12921  * generic initialization of ADC, input mixers and output mixers
12922  */
12923 static struct hda_verb alc269_init_verbs[] = {
12924         /*
12925          * Unmute ADC0 and set the default input to mic-in
12926          */
12927         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12928
12929         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12930          * analog-loopback mixer widget
12931          * Note: PASD motherboards uses the Line In 2 as the input for
12932          * front panel mic (mic 2)
12933          */
12934         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12935         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12936         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12937         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12938         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12939         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12940
12941         /*
12942          * Set up output mixers (0x0c - 0x0e)
12943          */
12944         /* set vol=0 to output mixers */
12945         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12946         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12947
12948         /* set up input amps for analog loopback */
12949         /* Amp Indices: DAC = 0, mixer = 1 */
12950         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12951         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12952         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12953         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12954         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12955         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12956
12957         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12958         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12959         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12960         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12961         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12962         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12963         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12964
12965         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12966         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12967         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12968         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12969         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12970         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12971         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12972
12973         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12974         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12975
12976         /* FIXME: use matrix-type input source selection */
12977         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12978         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12979         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12980         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12981         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12982         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12983
12984         /* set EAPD */
12985         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12986         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12987         { }
12988 };
12989
12990 /* add playback controls from the parsed DAC table */
12991 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12992                                              const struct auto_pin_cfg *cfg)
12993 {
12994         hda_nid_t nid;
12995         int err;
12996
12997         spec->multiout.num_dacs = 1;    /* only use one dac */
12998         spec->multiout.dac_nids = spec->private_dac_nids;
12999         spec->multiout.dac_nids[0] = 2;
13000
13001         nid = cfg->line_out_pins[0];
13002         if (nid) {
13003                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
13004                                   "Front Playback Volume",
13005                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
13006                 if (err < 0)
13007                         return err;
13008                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13009                                   "Front Playback Switch",
13010                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13011                 if (err < 0)
13012                         return err;
13013         }
13014
13015         nid = cfg->speaker_pins[0];
13016         if (nid) {
13017                 if (!cfg->line_out_pins[0]) {
13018                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
13019                                           "Speaker Playback Volume",
13020                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
13021                                                               HDA_OUTPUT));
13022                         if (err < 0)
13023                                 return err;
13024                 }
13025                 if (nid == 0x16) {
13026                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13027                                           "Speaker Playback Switch",
13028                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13029                                                               HDA_OUTPUT));
13030                         if (err < 0)
13031                                 return err;
13032                 } else {
13033                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13034                                           "Speaker Playback Switch",
13035                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13036                                                               HDA_OUTPUT));
13037                         if (err < 0)
13038                                 return err;
13039                 }
13040         }
13041         nid = cfg->hp_pins[0];
13042         if (nid) {
13043                 /* spec->multiout.hp_nid = 2; */
13044                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
13045                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
13046                                           "Headphone Playback Volume",
13047                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
13048                                                               HDA_OUTPUT));
13049                         if (err < 0)
13050                                 return err;
13051                 }
13052                 if (nid == 0x16) {
13053                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13054                                           "Headphone Playback Switch",
13055                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13056                                                               HDA_OUTPUT));
13057                         if (err < 0)
13058                                 return err;
13059                 } else {
13060                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13061                                           "Headphone Playback Switch",
13062                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13063                                                               HDA_OUTPUT));
13064                         if (err < 0)
13065                                 return err;
13066                 }
13067         }
13068         return 0;
13069 }
13070
13071 #define alc269_auto_create_analog_input_ctls \
13072         alc262_auto_create_analog_input_ctls
13073
13074 #ifdef CONFIG_SND_HDA_POWER_SAVE
13075 #define alc269_loopbacks        alc880_loopbacks
13076 #endif
13077
13078 /* pcm configuration: identical with ALC880 */
13079 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
13080 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
13081 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
13082 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
13083
13084 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
13085         .substreams = 1,
13086         .channels_min = 2,
13087         .channels_max = 8,
13088         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13089         /* NID is set in alc_build_pcms */
13090         .ops = {
13091                 .open = alc880_playback_pcm_open,
13092                 .prepare = alc880_playback_pcm_prepare,
13093                 .cleanup = alc880_playback_pcm_cleanup
13094         },
13095 };
13096
13097 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
13098         .substreams = 1,
13099         .channels_min = 2,
13100         .channels_max = 2,
13101         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13102         /* NID is set in alc_build_pcms */
13103 };
13104
13105 /*
13106  * BIOS auto configuration
13107  */
13108 static int alc269_parse_auto_config(struct hda_codec *codec)
13109 {
13110         struct alc_spec *spec = codec->spec;
13111         int err;
13112         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
13113
13114         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13115                                            alc269_ignore);
13116         if (err < 0)
13117                 return err;
13118
13119         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
13120         if (err < 0)
13121                 return err;
13122         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
13123         if (err < 0)
13124                 return err;
13125
13126         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13127
13128         if (spec->autocfg.dig_outs)
13129                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
13130
13131         if (spec->kctls.list)
13132                 add_mixer(spec, spec->kctls.list);
13133
13134         add_verb(spec, alc269_init_verbs);
13135         spec->num_mux_defs = 1;
13136         spec->input_mux = &spec->private_imux[0];
13137         /* set default input source */
13138         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
13139                                   0, AC_VERB_SET_CONNECT_SEL,
13140                                   spec->input_mux->items[0].index);
13141
13142         err = alc_auto_add_mic_boost(codec);
13143         if (err < 0)
13144                 return err;
13145
13146         if (!spec->cap_mixer && !spec->no_analog)
13147                 set_capture_mixer(spec);
13148
13149         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
13150
13151         return 1;
13152 }
13153
13154 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
13155 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
13156 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
13157
13158
13159 /* init callback for auto-configuration model -- overriding the default init */
13160 static void alc269_auto_init(struct hda_codec *codec)
13161 {
13162         struct alc_spec *spec = codec->spec;
13163         alc269_auto_init_multi_out(codec);
13164         alc269_auto_init_hp_out(codec);
13165         alc269_auto_init_analog_input(codec);
13166         if (spec->unsol_event)
13167                 alc_inithook(codec);
13168 }
13169
13170 /*
13171  * configuration and preset
13172  */
13173 static const char *alc269_models[ALC269_MODEL_LAST] = {
13174         [ALC269_BASIC]                  = "basic",
13175         [ALC269_QUANTA_FL1]             = "quanta",
13176         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
13177         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
13178         [ALC269_FUJITSU]                = "fujitsu",
13179         [ALC269_LIFEBOOK]               = "lifebook"
13180 };
13181
13182 static struct snd_pci_quirk alc269_cfg_tbl[] = {
13183         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
13184         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
13185                       ALC269_ASUS_EEEPC_P703),
13186         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_ASUS_EEEPC_P703),
13187         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_ASUS_EEEPC_P703),
13188         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_ASUS_EEEPC_P703),
13189         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_ASUS_EEEPC_P703),
13190         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_ASUS_EEEPC_P703),
13191         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_ASUS_EEEPC_P703),
13192         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
13193                       ALC269_ASUS_EEEPC_P901),
13194         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
13195                       ALC269_ASUS_EEEPC_P901),
13196         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_ASUS_EEEPC_P901),
13197         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
13198         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
13199         {}
13200 };
13201
13202 static struct alc_config_preset alc269_presets[] = {
13203         [ALC269_BASIC] = {
13204                 .mixers = { alc269_base_mixer },
13205                 .init_verbs = { alc269_init_verbs },
13206                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13207                 .dac_nids = alc269_dac_nids,
13208                 .hp_nid = 0x03,
13209                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13210                 .channel_mode = alc269_modes,
13211                 .input_mux = &alc269_capture_source,
13212         },
13213         [ALC269_QUANTA_FL1] = {
13214                 .mixers = { alc269_quanta_fl1_mixer },
13215                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
13216                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13217                 .dac_nids = alc269_dac_nids,
13218                 .hp_nid = 0x03,
13219                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13220                 .channel_mode = alc269_modes,
13221                 .input_mux = &alc269_capture_source,
13222                 .unsol_event = alc269_quanta_fl1_unsol_event,
13223                 .init_hook = alc269_quanta_fl1_init_hook,
13224         },
13225         [ALC269_ASUS_EEEPC_P703] = {
13226                 .mixers = { alc269_eeepc_mixer },
13227                 .cap_mixer = alc269_epc_capture_mixer,
13228                 .init_verbs = { alc269_init_verbs,
13229                                 alc269_eeepc_amic_init_verbs },
13230                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13231                 .dac_nids = alc269_dac_nids,
13232                 .hp_nid = 0x03,
13233                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13234                 .channel_mode = alc269_modes,
13235                 .input_mux = &alc269_eeepc_amic_capture_source,
13236                 .unsol_event = alc269_eeepc_amic_unsol_event,
13237                 .init_hook = alc269_eeepc_amic_inithook,
13238         },
13239         [ALC269_ASUS_EEEPC_P901] = {
13240                 .mixers = { alc269_eeepc_mixer },
13241                 .cap_mixer = alc269_epc_capture_mixer,
13242                 .init_verbs = { alc269_init_verbs,
13243                                 alc269_eeepc_dmic_init_verbs },
13244                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13245                 .dac_nids = alc269_dac_nids,
13246                 .hp_nid = 0x03,
13247                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13248                 .channel_mode = alc269_modes,
13249                 .input_mux = &alc269_eeepc_dmic_capture_source,
13250                 .unsol_event = alc269_eeepc_dmic_unsol_event,
13251                 .init_hook = alc269_eeepc_dmic_inithook,
13252         },
13253         [ALC269_FUJITSU] = {
13254                 .mixers = { alc269_fujitsu_mixer },
13255                 .cap_mixer = alc269_epc_capture_mixer,
13256                 .init_verbs = { alc269_init_verbs,
13257                                 alc269_eeepc_dmic_init_verbs },
13258                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13259                 .dac_nids = alc269_dac_nids,
13260                 .hp_nid = 0x03,
13261                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13262                 .channel_mode = alc269_modes,
13263                 .input_mux = &alc269_eeepc_dmic_capture_source,
13264                 .unsol_event = alc269_eeepc_dmic_unsol_event,
13265                 .init_hook = alc269_eeepc_dmic_inithook,
13266         },
13267         [ALC269_LIFEBOOK] = {
13268                 .mixers = { alc269_lifebook_mixer },
13269                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13270                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13271                 .dac_nids = alc269_dac_nids,
13272                 .hp_nid = 0x03,
13273                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13274                 .channel_mode = alc269_modes,
13275                 .input_mux = &alc269_capture_source,
13276                 .unsol_event = alc269_lifebook_unsol_event,
13277                 .init_hook = alc269_lifebook_init_hook,
13278         },
13279 };
13280
13281 static int patch_alc269(struct hda_codec *codec)
13282 {
13283         struct alc_spec *spec;
13284         int board_config;
13285         int err;
13286
13287         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13288         if (spec == NULL)
13289                 return -ENOMEM;
13290
13291         codec->spec = spec;
13292
13293         alc_fix_pll_init(codec, 0x20, 0x04, 15);
13294
13295         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13296                                                   alc269_models,
13297                                                   alc269_cfg_tbl);
13298
13299         if (board_config < 0) {
13300                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
13301                        "trying auto-probe from BIOS...\n", codec->chip_name);
13302                 board_config = ALC269_AUTO;
13303         }
13304
13305         if (board_config == ALC269_AUTO) {
13306                 /* automatic parse from the BIOS config */
13307                 err = alc269_parse_auto_config(codec);
13308                 if (err < 0) {
13309                         alc_free(codec);
13310                         return err;
13311                 } else if (!err) {
13312                         printk(KERN_INFO
13313                                "hda_codec: Cannot set up configuration "
13314                                "from BIOS.  Using base mode...\n");
13315                         board_config = ALC269_BASIC;
13316                 }
13317         }
13318
13319         err = snd_hda_attach_beep_device(codec, 0x1);
13320         if (err < 0) {
13321                 alc_free(codec);
13322                 return err;
13323         }
13324
13325         if (board_config != ALC269_AUTO)
13326                 setup_preset(spec, &alc269_presets[board_config]);
13327
13328         if (codec->subsystem_id == 0x17aa3bf8) {
13329                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
13330                  * fix the sample rate of analog I/O to 44.1kHz
13331                  */
13332                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
13333                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
13334         } else {
13335                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
13336                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
13337         }
13338         spec->stream_digital_playback = &alc269_pcm_digital_playback;
13339         spec->stream_digital_capture = &alc269_pcm_digital_capture;
13340
13341         spec->adc_nids = alc269_adc_nids;
13342         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13343         spec->capsrc_nids = alc269_capsrc_nids;
13344         if (!spec->cap_mixer)
13345                 set_capture_mixer(spec);
13346         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13347
13348         codec->patch_ops = alc_patch_ops;
13349         if (board_config == ALC269_AUTO)
13350                 spec->init_hook = alc269_auto_init;
13351 #ifdef CONFIG_SND_HDA_POWER_SAVE
13352         if (!spec->loopback.amplist)
13353                 spec->loopback.amplist = alc269_loopbacks;
13354 #endif
13355         codec->proc_widget_hook = print_realtek_coef;
13356
13357         return 0;
13358 }
13359
13360 /*
13361  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13362  */
13363
13364 /*
13365  * set the path ways for 2 channel output
13366  * need to set the codec line out and mic 1 pin widgets to inputs
13367  */
13368 static struct hda_verb alc861_threestack_ch2_init[] = {
13369         /* set pin widget 1Ah (line in) for input */
13370         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13371         /* set pin widget 18h (mic1/2) for input, for mic also enable
13372          * the vref
13373          */
13374         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13375
13376         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13377 #if 0
13378         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13379         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13380 #endif
13381         { } /* end */
13382 };
13383 /*
13384  * 6ch mode
13385  * need to set the codec line out and mic 1 pin widgets to outputs
13386  */
13387 static struct hda_verb alc861_threestack_ch6_init[] = {
13388         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13389         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13390         /* set pin widget 18h (mic1) for output (CLFE)*/
13391         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13392
13393         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13394         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13395
13396         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13397 #if 0
13398         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13399         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13400 #endif
13401         { } /* end */
13402 };
13403
13404 static struct hda_channel_mode alc861_threestack_modes[2] = {
13405         { 2, alc861_threestack_ch2_init },
13406         { 6, alc861_threestack_ch6_init },
13407 };
13408 /* Set mic1 as input and unmute the mixer */
13409 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13410         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13411         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13412         { } /* end */
13413 };
13414 /* Set mic1 as output and mute mixer */
13415 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13416         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13417         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13418         { } /* end */
13419 };
13420
13421 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13422         { 2, alc861_uniwill_m31_ch2_init },
13423         { 4, alc861_uniwill_m31_ch4_init },
13424 };
13425
13426 /* Set mic1 and line-in as input and unmute the mixer */
13427 static struct hda_verb alc861_asus_ch2_init[] = {
13428         /* set pin widget 1Ah (line in) for input */
13429         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13430         /* set pin widget 18h (mic1/2) for input, for mic also enable
13431          * the vref
13432          */
13433         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13434
13435         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13436 #if 0
13437         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13438         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13439 #endif
13440         { } /* end */
13441 };
13442 /* Set mic1 nad line-in as output and mute mixer */
13443 static struct hda_verb alc861_asus_ch6_init[] = {
13444         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13445         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13446         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13447         /* set pin widget 18h (mic1) for output (CLFE)*/
13448         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13449         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13450         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13451         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13452
13453         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13454 #if 0
13455         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13456         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13457 #endif
13458         { } /* end */
13459 };
13460
13461 static struct hda_channel_mode alc861_asus_modes[2] = {
13462         { 2, alc861_asus_ch2_init },
13463         { 6, alc861_asus_ch6_init },
13464 };
13465
13466 /* patch-ALC861 */
13467
13468 static struct snd_kcontrol_new alc861_base_mixer[] = {
13469         /* output mixer control */
13470         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13471         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13472         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13473         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13474         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13475
13476         /*Input mixer control */
13477         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13478            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13479         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13480         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13481         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13482         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13483         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13484         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13485         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13486         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13487
13488         { } /* end */
13489 };
13490
13491 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13492         /* output mixer control */
13493         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13494         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13495         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13496         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13497         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13498
13499         /* Input mixer control */
13500         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13501            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13502         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13503         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13504         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13505         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13506         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13507         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13508         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13509         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13510
13511         {
13512                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13513                 .name = "Channel Mode",
13514                 .info = alc_ch_mode_info,
13515                 .get = alc_ch_mode_get,
13516                 .put = alc_ch_mode_put,
13517                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13518         },
13519         { } /* end */
13520 };
13521
13522 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13523         /* output mixer control */
13524         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13525         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13526         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13527
13528         { } /* end */
13529 };
13530
13531 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13532         /* output mixer control */
13533         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13534         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13535         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13536         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13537         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13538
13539         /* Input mixer control */
13540         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13541            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13542         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13543         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13544         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13545         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13546         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13547         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13548         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13549         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13550
13551         {
13552                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13553                 .name = "Channel Mode",
13554                 .info = alc_ch_mode_info,
13555                 .get = alc_ch_mode_get,
13556                 .put = alc_ch_mode_put,
13557                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13558         },
13559         { } /* end */
13560 };
13561
13562 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13563         /* output mixer control */
13564         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13565         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13566         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13567         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13568         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13569
13570         /* Input mixer control */
13571         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13572         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13573         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13574         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13575         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13576         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13577         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13578         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13579         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13580         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13581
13582         {
13583                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13584                 .name = "Channel Mode",
13585                 .info = alc_ch_mode_info,
13586                 .get = alc_ch_mode_get,
13587                 .put = alc_ch_mode_put,
13588                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13589         },
13590         { }
13591 };
13592
13593 /* additional mixer */
13594 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13595         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13596         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13597         { }
13598 };
13599
13600 /*
13601  * generic initialization of ADC, input mixers and output mixers
13602  */
13603 static struct hda_verb alc861_base_init_verbs[] = {
13604         /*
13605          * Unmute ADC0 and set the default input to mic-in
13606          */
13607         /* port-A for surround (rear panel) */
13608         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13609         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
13610         /* port-B for mic-in (rear panel) with vref */
13611         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13612         /* port-C for line-in (rear panel) */
13613         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13614         /* port-D for Front */
13615         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13616         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13617         /* port-E for HP out (front panel) */
13618         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13619         /* route front PCM to HP */
13620         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13621         /* port-F for mic-in (front panel) with vref */
13622         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13623         /* port-G for CLFE (rear panel) */
13624         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13625         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13626         /* port-H for side (rear panel) */
13627         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13628         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
13629         /* CD-in */
13630         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13631         /* route front mic to ADC1*/
13632         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13633         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13634
13635         /* Unmute DAC0~3 & spdif out*/
13636         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13637         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13638         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13639         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13640         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13641
13642         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13643         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13644         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13645         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13646         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13647
13648         /* Unmute Stereo Mixer 15 */
13649         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13650         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13651         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13652         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13653
13654         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13655         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13656         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13657         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13658         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13659         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13660         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13661         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13662         /* hp used DAC 3 (Front) */
13663         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13664         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13665
13666         { }
13667 };
13668
13669 static struct hda_verb alc861_threestack_init_verbs[] = {
13670         /*
13671          * Unmute ADC0 and set the default input to mic-in
13672          */
13673         /* port-A for surround (rear panel) */
13674         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13675         /* port-B for mic-in (rear panel) with vref */
13676         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13677         /* port-C for line-in (rear panel) */
13678         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13679         /* port-D for Front */
13680         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13681         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13682         /* port-E for HP out (front panel) */
13683         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13684         /* route front PCM to HP */
13685         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13686         /* port-F for mic-in (front panel) with vref */
13687         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13688         /* port-G for CLFE (rear panel) */
13689         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13690         /* port-H for side (rear panel) */
13691         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13692         /* CD-in */
13693         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13694         /* route front mic to ADC1*/
13695         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13696         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13697         /* Unmute DAC0~3 & spdif out*/
13698         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13699         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13700         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13701         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13702         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13703
13704         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13705         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13706         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13707         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13708         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13709
13710         /* Unmute Stereo Mixer 15 */
13711         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13712         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13713         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13714         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13715
13716         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13717         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13718         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13719         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13720         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13721         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13722         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13723         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13724         /* hp used DAC 3 (Front) */
13725         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13726         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13727         { }
13728 };
13729
13730 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
13731         /*
13732          * Unmute ADC0 and set the default input to mic-in
13733          */
13734         /* port-A for surround (rear panel) */
13735         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13736         /* port-B for mic-in (rear panel) with vref */
13737         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13738         /* port-C for line-in (rear panel) */
13739         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13740         /* port-D for Front */
13741         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13742         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13743         /* port-E for HP out (front panel) */
13744         /* this has to be set to VREF80 */
13745         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13746         /* route front PCM to HP */
13747         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13748         /* port-F for mic-in (front panel) with vref */
13749         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13750         /* port-G for CLFE (rear panel) */
13751         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13752         /* port-H for side (rear panel) */
13753         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13754         /* CD-in */
13755         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13756         /* route front mic to ADC1*/
13757         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13758         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13759         /* Unmute DAC0~3 & spdif out*/
13760         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13761         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13762         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13763         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13764         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13765
13766         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13767         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13768         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13769         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13770         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13771
13772         /* Unmute Stereo Mixer 15 */
13773         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13774         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13775         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13776         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13777
13778         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13779         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13780         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13781         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13782         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13783         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13784         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13785         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13786         /* hp used DAC 3 (Front) */
13787         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13788         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13789         { }
13790 };
13791
13792 static struct hda_verb alc861_asus_init_verbs[] = {
13793         /*
13794          * Unmute ADC0 and set the default input to mic-in
13795          */
13796         /* port-A for surround (rear panel)
13797          * according to codec#0 this is the HP jack
13798          */
13799         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
13800         /* route front PCM to HP */
13801         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
13802         /* port-B for mic-in (rear panel) with vref */
13803         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13804         /* port-C for line-in (rear panel) */
13805         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13806         /* port-D for Front */
13807         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13808         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13809         /* port-E for HP out (front panel) */
13810         /* this has to be set to VREF80 */
13811         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13812         /* route front PCM to HP */
13813         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13814         /* port-F for mic-in (front panel) with vref */
13815         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13816         /* port-G for CLFE (rear panel) */
13817         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13818         /* port-H for side (rear panel) */
13819         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13820         /* CD-in */
13821         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13822         /* route front mic to ADC1*/
13823         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13824         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13825         /* Unmute DAC0~3 & spdif out*/
13826         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13827         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13828         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13829         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13830         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13831         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13832         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13833         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13834         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13835         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13836
13837         /* Unmute Stereo Mixer 15 */
13838         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13839         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13840         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13841         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13842
13843         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13844         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13845         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13846         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13847         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13848         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13849         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13850         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13851         /* hp used DAC 3 (Front) */
13852         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13853         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13854         { }
13855 };
13856
13857 /* additional init verbs for ASUS laptops */
13858 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
13859         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
13860         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
13861         { }
13862 };
13863
13864 /*
13865  * generic initialization of ADC, input mixers and output mixers
13866  */
13867 static struct hda_verb alc861_auto_init_verbs[] = {
13868         /*
13869          * Unmute ADC0 and set the default input to mic-in
13870          */
13871         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
13872         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13873
13874         /* Unmute DAC0~3 & spdif out*/
13875         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13876         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13877         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13878         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13879         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13880
13881         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13882         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13883         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13884         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13885         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13886
13887         /* Unmute Stereo Mixer 15 */
13888         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13889         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13890         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13891         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
13892
13893         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13894         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13895         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13896         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13897         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13898         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13899         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13900         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13901
13902         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13903         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13904         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13905         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13906         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13907         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13908         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13909         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13910
13911         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
13912
13913         { }
13914 };
13915
13916 static struct hda_verb alc861_toshiba_init_verbs[] = {
13917         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13918
13919         { }
13920 };
13921
13922 /* toggle speaker-output according to the hp-jack state */
13923 static void alc861_toshiba_automute(struct hda_codec *codec)
13924 {
13925         unsigned int present;
13926
13927         present = snd_hda_codec_read(codec, 0x0f, 0,
13928                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13929         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13930                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13931         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13932                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13933 }
13934
13935 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13936                                        unsigned int res)
13937 {
13938         if ((res >> 26) == ALC880_HP_EVENT)
13939                 alc861_toshiba_automute(codec);
13940 }
13941
13942 /* pcm configuration: identical with ALC880 */
13943 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
13944 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
13945 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
13946 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
13947
13948
13949 #define ALC861_DIGOUT_NID       0x07
13950
13951 static struct hda_channel_mode alc861_8ch_modes[1] = {
13952         { 8, NULL }
13953 };
13954
13955 static hda_nid_t alc861_dac_nids[4] = {
13956         /* front, surround, clfe, side */
13957         0x03, 0x06, 0x05, 0x04
13958 };
13959
13960 static hda_nid_t alc660_dac_nids[3] = {
13961         /* front, clfe, surround */
13962         0x03, 0x05, 0x06
13963 };
13964
13965 static hda_nid_t alc861_adc_nids[1] = {
13966         /* ADC0-2 */
13967         0x08,
13968 };
13969
13970 static struct hda_input_mux alc861_capture_source = {
13971         .num_items = 5,
13972         .items = {
13973                 { "Mic", 0x0 },
13974                 { "Front Mic", 0x3 },
13975                 { "Line", 0x1 },
13976                 { "CD", 0x4 },
13977                 { "Mixer", 0x5 },
13978         },
13979 };
13980
13981 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
13982 {
13983         struct alc_spec *spec = codec->spec;
13984         hda_nid_t mix, srcs[5];
13985         int i, j, num;
13986
13987         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
13988                 return 0;
13989         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
13990         if (num < 0)
13991                 return 0;
13992         for (i = 0; i < num; i++) {
13993                 unsigned int type;
13994                 type = (get_wcaps(codec, srcs[i]) & AC_WCAP_TYPE)
13995                         >> AC_WCAP_TYPE_SHIFT;
13996                 if (type != AC_WID_AUD_OUT)
13997                         continue;
13998                 for (j = 0; j < spec->multiout.num_dacs; j++)
13999                         if (spec->multiout.dac_nids[j] == srcs[i])
14000                                 break;
14001                 if (j >= spec->multiout.num_dacs)
14002                         return srcs[i];
14003         }
14004         return 0;
14005 }
14006
14007 /* fill in the dac_nids table from the parsed pin configuration */
14008 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
14009                                      const struct auto_pin_cfg *cfg)
14010 {
14011         struct alc_spec *spec = codec->spec;
14012         int i;
14013         hda_nid_t nid, dac;
14014
14015         spec->multiout.dac_nids = spec->private_dac_nids;
14016         for (i = 0; i < cfg->line_outs; i++) {
14017                 nid = cfg->line_out_pins[i];
14018                 dac = alc861_look_for_dac(codec, nid);
14019                 if (!dac)
14020                         continue;
14021                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
14022         }
14023         return 0;
14024 }
14025
14026 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
14027                                 hda_nid_t nid, unsigned int chs)
14028 {
14029         char name[32];
14030         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
14031         return add_control(codec->spec, ALC_CTL_WIDGET_MUTE, name,
14032                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
14033 }
14034
14035 /* add playback controls from the parsed DAC table */
14036 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
14037                                              const struct auto_pin_cfg *cfg)
14038 {
14039         struct alc_spec *spec = codec->spec;
14040         static const char *chname[4] = {
14041                 "Front", "Surround", NULL /*CLFE*/, "Side"
14042         };
14043         hda_nid_t nid;
14044         int i, err;
14045
14046         if (cfg->line_outs == 1) {
14047                 const char *pfx = NULL;
14048                 if (!cfg->hp_outs)
14049                         pfx = "Master";
14050                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
14051                         pfx = "Speaker";
14052                 if (pfx) {
14053                         nid = spec->multiout.dac_nids[0];
14054                         return alc861_create_out_sw(codec, pfx, nid, 3);
14055                 }
14056         }
14057
14058         for (i = 0; i < cfg->line_outs; i++) {
14059                 nid = spec->multiout.dac_nids[i];
14060                 if (!nid)
14061                         continue;
14062                 if (i == 2) {
14063                         /* Center/LFE */
14064                         err = alc861_create_out_sw(codec, "Center", nid, 1);
14065                         if (err < 0)
14066                                 return err;
14067                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
14068                         if (err < 0)
14069                                 return err;
14070                 } else {
14071                         err = alc861_create_out_sw(codec, chname[i], nid, 3);
14072                         if (err < 0)
14073                                 return err;
14074                 }
14075         }
14076         return 0;
14077 }
14078
14079 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
14080 {
14081         struct alc_spec *spec = codec->spec;
14082         int err;
14083         hda_nid_t nid;
14084
14085         if (!pin)
14086                 return 0;
14087
14088         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
14089                 nid = alc861_look_for_dac(codec, pin);
14090                 if (nid) {
14091                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
14092                         if (err < 0)
14093                                 return err;
14094                         spec->multiout.hp_nid = nid;
14095                 }
14096         }
14097         return 0;
14098 }
14099
14100 /* create playback/capture controls for input pins */
14101 static int alc861_auto_create_analog_input_ctls(struct hda_codec *codec,
14102                                                 const struct auto_pin_cfg *cfg)
14103 {
14104         struct alc_spec *spec = codec->spec;
14105         struct hda_input_mux *imux = &spec->private_imux[0];
14106         int i, err, idx, idx1;
14107
14108         for (i = 0; i < AUTO_PIN_LAST; i++) {
14109                 switch (cfg->input_pins[i]) {
14110                 case 0x0c:
14111                         idx1 = 1;
14112                         idx = 2;        /* Line In */
14113                         break;
14114                 case 0x0f:
14115                         idx1 = 2;
14116                         idx = 2;        /* Line In */
14117                         break;
14118                 case 0x0d:
14119                         idx1 = 0;
14120                         idx = 1;        /* Mic In */
14121                         break;
14122                 case 0x10:
14123                         idx1 = 3;
14124                         idx = 1;        /* Mic In */
14125                         break;
14126                 case 0x11:
14127                         idx1 = 4;
14128                         idx = 0;        /* CD */
14129                         break;
14130                 default:
14131                         continue;
14132                 }
14133
14134                 err = new_analog_input(spec, cfg->input_pins[i],
14135                                        auto_pin_cfg_labels[i], idx, 0x15);
14136                 if (err < 0)
14137                         return err;
14138
14139                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
14140                 imux->items[imux->num_items].index = idx1;
14141                 imux->num_items++;
14142         }
14143         return 0;
14144 }
14145
14146 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
14147                                               hda_nid_t nid,
14148                                               int pin_type, hda_nid_t dac)
14149 {
14150         hda_nid_t mix, srcs[5];
14151         int i, num;
14152
14153         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
14154                             pin_type);
14155         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14156                             AMP_OUT_UNMUTE);
14157         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
14158                 return;
14159         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14160         if (num < 0)
14161                 return;
14162         for (i = 0; i < num; i++) {
14163                 unsigned int mute;
14164                 if (srcs[i] == dac || srcs[i] == 0x15)
14165                         mute = AMP_IN_UNMUTE(i);
14166                 else
14167                         mute = AMP_IN_MUTE(i);
14168                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14169                                     mute);
14170         }
14171 }
14172
14173 static void alc861_auto_init_multi_out(struct hda_codec *codec)
14174 {
14175         struct alc_spec *spec = codec->spec;
14176         int i;
14177
14178         for (i = 0; i < spec->autocfg.line_outs; i++) {
14179                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14180                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14181                 if (nid)
14182                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
14183                                                           spec->multiout.dac_nids[i]);
14184         }
14185 }
14186
14187 static void alc861_auto_init_hp_out(struct hda_codec *codec)
14188 {
14189         struct alc_spec *spec = codec->spec;
14190         hda_nid_t pin;
14191
14192         pin = spec->autocfg.hp_pins[0];
14193         if (pin)
14194                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
14195                                                   spec->multiout.hp_nid);
14196         pin = spec->autocfg.speaker_pins[0];
14197         if (pin)
14198                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT,
14199                                                   spec->multiout.dac_nids[0]);
14200 }
14201
14202 static void alc861_auto_init_analog_input(struct hda_codec *codec)
14203 {
14204         struct alc_spec *spec = codec->spec;
14205         int i;
14206
14207         for (i = 0; i < AUTO_PIN_LAST; i++) {
14208                 hda_nid_t nid = spec->autocfg.input_pins[i];
14209                 if (nid >= 0x0c && nid <= 0x11)
14210                         alc_set_input_pin(codec, nid, i);
14211         }
14212 }
14213
14214 /* parse the BIOS configuration and set up the alc_spec */
14215 /* return 1 if successful, 0 if the proper config is not found,
14216  * or a negative error code
14217  */
14218 static int alc861_parse_auto_config(struct hda_codec *codec)
14219 {
14220         struct alc_spec *spec = codec->spec;
14221         int err;
14222         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
14223
14224         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14225                                            alc861_ignore);
14226         if (err < 0)
14227                 return err;
14228         if (!spec->autocfg.line_outs)
14229                 return 0; /* can't find valid BIOS pin config */
14230
14231         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
14232         if (err < 0)
14233                 return err;
14234         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
14235         if (err < 0)
14236                 return err;
14237         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
14238         if (err < 0)
14239                 return err;
14240         err = alc861_auto_create_analog_input_ctls(codec, &spec->autocfg);
14241         if (err < 0)
14242                 return err;
14243
14244         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14245
14246         if (spec->autocfg.dig_outs)
14247                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
14248
14249         if (spec->kctls.list)
14250                 add_mixer(spec, spec->kctls.list);
14251
14252         add_verb(spec, alc861_auto_init_verbs);
14253
14254         spec->num_mux_defs = 1;
14255         spec->input_mux = &spec->private_imux[0];
14256
14257         spec->adc_nids = alc861_adc_nids;
14258         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
14259         set_capture_mixer(spec);
14260
14261         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b);
14262
14263         return 1;
14264 }
14265
14266 /* additional initialization for auto-configuration model */
14267 static void alc861_auto_init(struct hda_codec *codec)
14268 {
14269         struct alc_spec *spec = codec->spec;
14270         alc861_auto_init_multi_out(codec);
14271         alc861_auto_init_hp_out(codec);
14272         alc861_auto_init_analog_input(codec);
14273         if (spec->unsol_event)
14274                 alc_inithook(codec);
14275 }
14276
14277 #ifdef CONFIG_SND_HDA_POWER_SAVE
14278 static struct hda_amp_list alc861_loopbacks[] = {
14279         { 0x15, HDA_INPUT, 0 },
14280         { 0x15, HDA_INPUT, 1 },
14281         { 0x15, HDA_INPUT, 2 },
14282         { 0x15, HDA_INPUT, 3 },
14283         { } /* end */
14284 };
14285 #endif
14286
14287
14288 /*
14289  * configuration and preset
14290  */
14291 static const char *alc861_models[ALC861_MODEL_LAST] = {
14292         [ALC861_3ST]            = "3stack",
14293         [ALC660_3ST]            = "3stack-660",
14294         [ALC861_3ST_DIG]        = "3stack-dig",
14295         [ALC861_6ST_DIG]        = "6stack-dig",
14296         [ALC861_UNIWILL_M31]    = "uniwill-m31",
14297         [ALC861_TOSHIBA]        = "toshiba",
14298         [ALC861_ASUS]           = "asus",
14299         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
14300         [ALC861_AUTO]           = "auto",
14301 };
14302
14303 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14304         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14305         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14306         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14307         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14308         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14309         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14310         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14311         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14312          *        Any other models that need this preset?
14313          */
14314         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14315         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14316         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14317         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14318         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14319         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14320         /* FIXME: the below seems conflict */
14321         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14322         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14323         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14324         {}
14325 };
14326
14327 static struct alc_config_preset alc861_presets[] = {
14328         [ALC861_3ST] = {
14329                 .mixers = { alc861_3ST_mixer },
14330                 .init_verbs = { alc861_threestack_init_verbs },
14331                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14332                 .dac_nids = alc861_dac_nids,
14333                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14334                 .channel_mode = alc861_threestack_modes,
14335                 .need_dac_fix = 1,
14336                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14337                 .adc_nids = alc861_adc_nids,
14338                 .input_mux = &alc861_capture_source,
14339         },
14340         [ALC861_3ST_DIG] = {
14341                 .mixers = { alc861_base_mixer },
14342                 .init_verbs = { alc861_threestack_init_verbs },
14343                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14344                 .dac_nids = alc861_dac_nids,
14345                 .dig_out_nid = ALC861_DIGOUT_NID,
14346                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14347                 .channel_mode = alc861_threestack_modes,
14348                 .need_dac_fix = 1,
14349                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14350                 .adc_nids = alc861_adc_nids,
14351                 .input_mux = &alc861_capture_source,
14352         },
14353         [ALC861_6ST_DIG] = {
14354                 .mixers = { alc861_base_mixer },
14355                 .init_verbs = { alc861_base_init_verbs },
14356                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14357                 .dac_nids = alc861_dac_nids,
14358                 .dig_out_nid = ALC861_DIGOUT_NID,
14359                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14360                 .channel_mode = alc861_8ch_modes,
14361                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14362                 .adc_nids = alc861_adc_nids,
14363                 .input_mux = &alc861_capture_source,
14364         },
14365         [ALC660_3ST] = {
14366                 .mixers = { alc861_3ST_mixer },
14367                 .init_verbs = { alc861_threestack_init_verbs },
14368                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
14369                 .dac_nids = alc660_dac_nids,
14370                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14371                 .channel_mode = alc861_threestack_modes,
14372                 .need_dac_fix = 1,
14373                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14374                 .adc_nids = alc861_adc_nids,
14375                 .input_mux = &alc861_capture_source,
14376         },
14377         [ALC861_UNIWILL_M31] = {
14378                 .mixers = { alc861_uniwill_m31_mixer },
14379                 .init_verbs = { alc861_uniwill_m31_init_verbs },
14380                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14381                 .dac_nids = alc861_dac_nids,
14382                 .dig_out_nid = ALC861_DIGOUT_NID,
14383                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14384                 .channel_mode = alc861_uniwill_m31_modes,
14385                 .need_dac_fix = 1,
14386                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14387                 .adc_nids = alc861_adc_nids,
14388                 .input_mux = &alc861_capture_source,
14389         },
14390         [ALC861_TOSHIBA] = {
14391                 .mixers = { alc861_toshiba_mixer },
14392                 .init_verbs = { alc861_base_init_verbs,
14393                                 alc861_toshiba_init_verbs },
14394                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14395                 .dac_nids = alc861_dac_nids,
14396                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14397                 .channel_mode = alc883_3ST_2ch_modes,
14398                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14399                 .adc_nids = alc861_adc_nids,
14400                 .input_mux = &alc861_capture_source,
14401                 .unsol_event = alc861_toshiba_unsol_event,
14402                 .init_hook = alc861_toshiba_automute,
14403         },
14404         [ALC861_ASUS] = {
14405                 .mixers = { alc861_asus_mixer },
14406                 .init_verbs = { alc861_asus_init_verbs },
14407                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14408                 .dac_nids = alc861_dac_nids,
14409                 .dig_out_nid = ALC861_DIGOUT_NID,
14410                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14411                 .channel_mode = alc861_asus_modes,
14412                 .need_dac_fix = 1,
14413                 .hp_nid = 0x06,
14414                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14415                 .adc_nids = alc861_adc_nids,
14416                 .input_mux = &alc861_capture_source,
14417         },
14418         [ALC861_ASUS_LAPTOP] = {
14419                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14420                 .init_verbs = { alc861_asus_init_verbs,
14421                                 alc861_asus_laptop_init_verbs },
14422                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14423                 .dac_nids = alc861_dac_nids,
14424                 .dig_out_nid = ALC861_DIGOUT_NID,
14425                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14426                 .channel_mode = alc883_3ST_2ch_modes,
14427                 .need_dac_fix = 1,
14428                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14429                 .adc_nids = alc861_adc_nids,
14430                 .input_mux = &alc861_capture_source,
14431         },
14432 };
14433
14434
14435 static int patch_alc861(struct hda_codec *codec)
14436 {
14437         struct alc_spec *spec;
14438         int board_config;
14439         int err;
14440
14441         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14442         if (spec == NULL)
14443                 return -ENOMEM;
14444
14445         codec->spec = spec;
14446
14447         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14448                                                   alc861_models,
14449                                                   alc861_cfg_tbl);
14450
14451         if (board_config < 0) {
14452                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
14453                        "trying auto-probe from BIOS...\n", codec->chip_name);
14454                 board_config = ALC861_AUTO;
14455         }
14456
14457         if (board_config == ALC861_AUTO) {
14458                 /* automatic parse from the BIOS config */
14459                 err = alc861_parse_auto_config(codec);
14460                 if (err < 0) {
14461                         alc_free(codec);
14462                         return err;
14463                 } else if (!err) {
14464                         printk(KERN_INFO
14465                                "hda_codec: Cannot set up configuration "
14466                                "from BIOS.  Using base mode...\n");
14467                    board_config = ALC861_3ST_DIG;
14468                 }
14469         }
14470
14471         err = snd_hda_attach_beep_device(codec, 0x23);
14472         if (err < 0) {
14473                 alc_free(codec);
14474                 return err;
14475         }
14476
14477         if (board_config != ALC861_AUTO)
14478                 setup_preset(spec, &alc861_presets[board_config]);
14479
14480         spec->stream_analog_playback = &alc861_pcm_analog_playback;
14481         spec->stream_analog_capture = &alc861_pcm_analog_capture;
14482
14483         spec->stream_digital_playback = &alc861_pcm_digital_playback;
14484         spec->stream_digital_capture = &alc861_pcm_digital_capture;
14485
14486         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14487
14488         spec->vmaster_nid = 0x03;
14489
14490         codec->patch_ops = alc_patch_ops;
14491         if (board_config == ALC861_AUTO)
14492                 spec->init_hook = alc861_auto_init;
14493 #ifdef CONFIG_SND_HDA_POWER_SAVE
14494         if (!spec->loopback.amplist)
14495                 spec->loopback.amplist = alc861_loopbacks;
14496 #endif
14497         codec->proc_widget_hook = print_realtek_coef;
14498
14499         return 0;
14500 }
14501
14502 /*
14503  * ALC861-VD support
14504  *
14505  * Based on ALC882
14506  *
14507  * In addition, an independent DAC
14508  */
14509 #define ALC861VD_DIGOUT_NID     0x06
14510
14511 static hda_nid_t alc861vd_dac_nids[4] = {
14512         /* front, surr, clfe, side surr */
14513         0x02, 0x03, 0x04, 0x05
14514 };
14515
14516 /* dac_nids for ALC660vd are in a different order - according to
14517  * Realtek's driver.
14518  * This should probably result in a different mixer for 6stack models
14519  * of ALC660vd codecs, but for now there is only 3stack mixer
14520  * - and it is the same as in 861vd.
14521  * adc_nids in ALC660vd are (is) the same as in 861vd
14522  */
14523 static hda_nid_t alc660vd_dac_nids[3] = {
14524         /* front, rear, clfe, rear_surr */
14525         0x02, 0x04, 0x03
14526 };
14527
14528 static hda_nid_t alc861vd_adc_nids[1] = {
14529         /* ADC0 */
14530         0x09,
14531 };
14532
14533 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14534
14535 /* input MUX */
14536 /* FIXME: should be a matrix-type input source selection */
14537 static struct hda_input_mux alc861vd_capture_source = {
14538         .num_items = 4,
14539         .items = {
14540                 { "Mic", 0x0 },
14541                 { "Front Mic", 0x1 },
14542                 { "Line", 0x2 },
14543                 { "CD", 0x4 },
14544         },
14545 };
14546
14547 static struct hda_input_mux alc861vd_dallas_capture_source = {
14548         .num_items = 2,
14549         .items = {
14550                 { "Ext Mic", 0x0 },
14551                 { "Int Mic", 0x1 },
14552         },
14553 };
14554
14555 static struct hda_input_mux alc861vd_hp_capture_source = {
14556         .num_items = 2,
14557         .items = {
14558                 { "Front Mic", 0x0 },
14559                 { "ATAPI Mic", 0x1 },
14560         },
14561 };
14562
14563 /*
14564  * 2ch mode
14565  */
14566 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14567         { 2, NULL }
14568 };
14569
14570 /*
14571  * 6ch mode
14572  */
14573 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14574         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14575         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14576         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14577         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14578         { } /* end */
14579 };
14580
14581 /*
14582  * 8ch mode
14583  */
14584 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14585         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14586         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14587         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14588         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14589         { } /* end */
14590 };
14591
14592 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14593         { 6, alc861vd_6stack_ch6_init },
14594         { 8, alc861vd_6stack_ch8_init },
14595 };
14596
14597 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14598         {
14599                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14600                 .name = "Channel Mode",
14601                 .info = alc_ch_mode_info,
14602                 .get = alc_ch_mode_get,
14603                 .put = alc_ch_mode_put,
14604         },
14605         { } /* end */
14606 };
14607
14608 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14609  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14610  */
14611 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14612         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14613         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14614
14615         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14616         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14617
14618         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14619                                 HDA_OUTPUT),
14620         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14621                                 HDA_OUTPUT),
14622         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14623         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14624
14625         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14626         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14627
14628         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14629
14630         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14631         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14632         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14633
14634         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14635         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14636         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14637
14638         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14639         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14640
14641         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14642         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14643
14644         { } /* end */
14645 };
14646
14647 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
14648         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14649         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14650
14651         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14652
14653         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14654         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14655         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14656
14657         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14658         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14659         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14660
14661         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14662         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14663
14664         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14665         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14666
14667         { } /* end */
14668 };
14669
14670 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
14671         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14672         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
14673         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14674
14675         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14676
14677         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14678         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14679         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14680
14681         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14682         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14683         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14684
14685         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14686         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14687
14688         { } /* end */
14689 };
14690
14691 /* Pin assignment: Speaker=0x14, HP = 0x15,
14692  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
14693  */
14694 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
14695         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14696         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
14697         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14698         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14699         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
14700         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14701         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14702         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
14703         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14704         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14705         { } /* end */
14706 };
14707
14708 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
14709  *                 Front Mic=0x18, ATAPI Mic = 0x19,
14710  */
14711 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
14712         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14713         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14714         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14715         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14716         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14717         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14718         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14719         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14720
14721         { } /* end */
14722 };
14723
14724 /*
14725  * generic initialization of ADC, input mixers and output mixers
14726  */
14727 static struct hda_verb alc861vd_volume_init_verbs[] = {
14728         /*
14729          * Unmute ADC0 and set the default input to mic-in
14730          */
14731         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14732         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14733
14734         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
14735          * the analog-loopback mixer widget
14736          */
14737         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14738         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14739         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14740         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14741         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14742         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14743
14744         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
14745         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14746         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14747         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14748         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14749
14750         /*
14751          * Set up output mixers (0x02 - 0x05)
14752          */
14753         /* set vol=0 to output mixers */
14754         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14755         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14756         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14757         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14758
14759         /* set up input amps for analog loopback */
14760         /* Amp Indices: DAC = 0, mixer = 1 */
14761         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14762         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14763         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14764         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14765         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14766         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14767         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14768         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14769
14770         { }
14771 };
14772
14773 /*
14774  * 3-stack pin configuration:
14775  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
14776  */
14777 static struct hda_verb alc861vd_3stack_init_verbs[] = {
14778         /*
14779          * Set pin mode and muting
14780          */
14781         /* set front pin widgets 0x14 for output */
14782         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14783         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14784         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14785
14786         /* Mic (rear) pin: input vref at 80% */
14787         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14788         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14789         /* Front Mic pin: input vref at 80% */
14790         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14791         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14792         /* Line In pin: input */
14793         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14794         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14795         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14796         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14797         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14798         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14799         /* CD pin widget for input */
14800         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14801
14802         { }
14803 };
14804
14805 /*
14806  * 6-stack pin configuration:
14807  */
14808 static struct hda_verb alc861vd_6stack_init_verbs[] = {
14809         /*
14810          * Set pin mode and muting
14811          */
14812         /* set front pin widgets 0x14 for output */
14813         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14814         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14815         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14816
14817         /* Rear Pin: output 1 (0x0d) */
14818         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14819         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14820         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14821         /* CLFE Pin: output 2 (0x0e) */
14822         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14823         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14824         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
14825         /* Side Pin: output 3 (0x0f) */
14826         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14827         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14828         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
14829
14830         /* Mic (rear) pin: input vref at 80% */
14831         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14832         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14833         /* Front Mic pin: input vref at 80% */
14834         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14835         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14836         /* Line In pin: input */
14837         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14838         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14839         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14840         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14841         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14842         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14843         /* CD pin widget for input */
14844         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14845
14846         { }
14847 };
14848
14849 static struct hda_verb alc861vd_eapd_verbs[] = {
14850         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14851         { }
14852 };
14853
14854 static struct hda_verb alc660vd_eapd_verbs[] = {
14855         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14856         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14857         { }
14858 };
14859
14860 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
14861         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14862         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14863         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
14864         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14865         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14866         {}
14867 };
14868
14869 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
14870 {
14871         unsigned int present;
14872         unsigned char bits;
14873
14874         present = snd_hda_codec_read(codec, 0x18, 0,
14875                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14876         bits = present ? HDA_AMP_MUTE : 0;
14877         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
14878                                  HDA_AMP_MUTE, bits);
14879 }
14880
14881 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
14882 {
14883         struct alc_spec *spec = codec->spec;
14884
14885         spec->autocfg.hp_pins[0] = 0x1b;
14886         spec->autocfg.speaker_pins[0] = 0x14;
14887         alc_automute_amp(codec);
14888         alc861vd_lenovo_mic_automute(codec);
14889 }
14890
14891 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
14892                                         unsigned int res)
14893 {
14894         switch (res >> 26) {
14895         case ALC880_MIC_EVENT:
14896                 alc861vd_lenovo_mic_automute(codec);
14897                 break;
14898         default:
14899                 alc_automute_amp_unsol_event(codec, res);
14900                 break;
14901         }
14902 }
14903
14904 static struct hda_verb alc861vd_dallas_verbs[] = {
14905         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14906         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14907         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14908         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14909
14910         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14911         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14912         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14913         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14914         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14915         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14916         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14917         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14918
14919         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14920         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14921         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14922         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14923         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14924         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14925         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14926         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14927
14928         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14929         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14930         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14931         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14932         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14933         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14934         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14935         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14936
14937         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14938         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14939         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14940         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14941
14942         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14943         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14944         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14945
14946         { } /* end */
14947 };
14948
14949 /* toggle speaker-output according to the hp-jack state */
14950 static void alc861vd_dallas_init_hook(struct hda_codec *codec)
14951 {
14952         struct alc_spec *spec = codec->spec;
14953
14954         spec->autocfg.hp_pins[0] = 0x15;
14955         spec->autocfg.speaker_pins[0] = 0x14;
14956         alc_automute_amp(codec);
14957 }
14958
14959 #ifdef CONFIG_SND_HDA_POWER_SAVE
14960 #define alc861vd_loopbacks      alc880_loopbacks
14961 #endif
14962
14963 /* pcm configuration: identical with ALC880 */
14964 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
14965 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
14966 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
14967 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
14968
14969 /*
14970  * configuration and preset
14971  */
14972 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14973         [ALC660VD_3ST]          = "3stack-660",
14974         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
14975         [ALC660VD_ASUS_V1S]     = "asus-v1s",
14976         [ALC861VD_3ST]          = "3stack",
14977         [ALC861VD_3ST_DIG]      = "3stack-digout",
14978         [ALC861VD_6ST_DIG]      = "6stack-digout",
14979         [ALC861VD_LENOVO]       = "lenovo",
14980         [ALC861VD_DALLAS]       = "dallas",
14981         [ALC861VD_HP]           = "hp",
14982         [ALC861VD_AUTO]         = "auto",
14983 };
14984
14985 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14986         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14987         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14988         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14989         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14990         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
14991         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14992         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14993         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14994         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14995         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14996         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14997         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14998         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14999         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
15000         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
15001         {}
15002 };
15003
15004 static struct alc_config_preset alc861vd_presets[] = {
15005         [ALC660VD_3ST] = {
15006                 .mixers = { alc861vd_3st_mixer },
15007                 .init_verbs = { alc861vd_volume_init_verbs,
15008                                  alc861vd_3stack_init_verbs },
15009                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15010                 .dac_nids = alc660vd_dac_nids,
15011                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15012                 .channel_mode = alc861vd_3stack_2ch_modes,
15013                 .input_mux = &alc861vd_capture_source,
15014         },
15015         [ALC660VD_3ST_DIG] = {
15016                 .mixers = { alc861vd_3st_mixer },
15017                 .init_verbs = { alc861vd_volume_init_verbs,
15018                                  alc861vd_3stack_init_verbs },
15019                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15020                 .dac_nids = alc660vd_dac_nids,
15021                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15022                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15023                 .channel_mode = alc861vd_3stack_2ch_modes,
15024                 .input_mux = &alc861vd_capture_source,
15025         },
15026         [ALC861VD_3ST] = {
15027                 .mixers = { alc861vd_3st_mixer },
15028                 .init_verbs = { alc861vd_volume_init_verbs,
15029                                  alc861vd_3stack_init_verbs },
15030                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15031                 .dac_nids = alc861vd_dac_nids,
15032                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15033                 .channel_mode = alc861vd_3stack_2ch_modes,
15034                 .input_mux = &alc861vd_capture_source,
15035         },
15036         [ALC861VD_3ST_DIG] = {
15037                 .mixers = { alc861vd_3st_mixer },
15038                 .init_verbs = { alc861vd_volume_init_verbs,
15039                                  alc861vd_3stack_init_verbs },
15040                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15041                 .dac_nids = alc861vd_dac_nids,
15042                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15043                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15044                 .channel_mode = alc861vd_3stack_2ch_modes,
15045                 .input_mux = &alc861vd_capture_source,
15046         },
15047         [ALC861VD_6ST_DIG] = {
15048                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
15049                 .init_verbs = { alc861vd_volume_init_verbs,
15050                                 alc861vd_6stack_init_verbs },
15051                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15052                 .dac_nids = alc861vd_dac_nids,
15053                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15054                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
15055                 .channel_mode = alc861vd_6stack_modes,
15056                 .input_mux = &alc861vd_capture_source,
15057         },
15058         [ALC861VD_LENOVO] = {
15059                 .mixers = { alc861vd_lenovo_mixer },
15060                 .init_verbs = { alc861vd_volume_init_verbs,
15061                                 alc861vd_3stack_init_verbs,
15062                                 alc861vd_eapd_verbs,
15063                                 alc861vd_lenovo_unsol_verbs },
15064                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15065                 .dac_nids = alc660vd_dac_nids,
15066                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15067                 .channel_mode = alc861vd_3stack_2ch_modes,
15068                 .input_mux = &alc861vd_capture_source,
15069                 .unsol_event = alc861vd_lenovo_unsol_event,
15070                 .init_hook = alc861vd_lenovo_init_hook,
15071         },
15072         [ALC861VD_DALLAS] = {
15073                 .mixers = { alc861vd_dallas_mixer },
15074                 .init_verbs = { alc861vd_dallas_verbs },
15075                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15076                 .dac_nids = alc861vd_dac_nids,
15077                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15078                 .channel_mode = alc861vd_3stack_2ch_modes,
15079                 .input_mux = &alc861vd_dallas_capture_source,
15080                 .unsol_event = alc_automute_amp_unsol_event,
15081                 .init_hook = alc861vd_dallas_init_hook,
15082         },
15083         [ALC861VD_HP] = {
15084                 .mixers = { alc861vd_hp_mixer },
15085                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
15086                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15087                 .dac_nids = alc861vd_dac_nids,
15088                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15089                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15090                 .channel_mode = alc861vd_3stack_2ch_modes,
15091                 .input_mux = &alc861vd_hp_capture_source,
15092                 .unsol_event = alc_automute_amp_unsol_event,
15093                 .init_hook = alc861vd_dallas_init_hook,
15094         },
15095         [ALC660VD_ASUS_V1S] = {
15096                 .mixers = { alc861vd_lenovo_mixer },
15097                 .init_verbs = { alc861vd_volume_init_verbs,
15098                                 alc861vd_3stack_init_verbs,
15099                                 alc861vd_eapd_verbs,
15100                                 alc861vd_lenovo_unsol_verbs },
15101                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15102                 .dac_nids = alc660vd_dac_nids,
15103                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15104                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15105                 .channel_mode = alc861vd_3stack_2ch_modes,
15106                 .input_mux = &alc861vd_capture_source,
15107                 .unsol_event = alc861vd_lenovo_unsol_event,
15108                 .init_hook = alc861vd_lenovo_init_hook,
15109         },
15110 };
15111
15112 /*
15113  * BIOS auto configuration
15114  */
15115 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
15116                                 hda_nid_t nid, int pin_type, int dac_idx)
15117 {
15118         alc_set_pin_output(codec, nid, pin_type);
15119 }
15120
15121 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
15122 {
15123         struct alc_spec *spec = codec->spec;
15124         int i;
15125
15126         for (i = 0; i <= HDA_SIDE; i++) {
15127                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
15128                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
15129                 if (nid)
15130                         alc861vd_auto_set_output_and_unmute(codec, nid,
15131                                                             pin_type, i);
15132         }
15133 }
15134
15135
15136 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
15137 {
15138         struct alc_spec *spec = codec->spec;
15139         hda_nid_t pin;
15140
15141         pin = spec->autocfg.hp_pins[0];
15142         if (pin) /* connect to front and use dac 0 */
15143                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
15144         pin = spec->autocfg.speaker_pins[0];
15145         if (pin)
15146                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
15147 }
15148
15149 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
15150 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
15151
15152 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
15153 {
15154         struct alc_spec *spec = codec->spec;
15155         int i;
15156
15157         for (i = 0; i < AUTO_PIN_LAST; i++) {
15158                 hda_nid_t nid = spec->autocfg.input_pins[i];
15159                 if (alc861vd_is_input_pin(nid)) {
15160                         alc_set_input_pin(codec, nid, i);
15161                         if (nid != ALC861VD_PIN_CD_NID &&
15162                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
15163                                 snd_hda_codec_write(codec, nid, 0,
15164                                                 AC_VERB_SET_AMP_GAIN_MUTE,
15165                                                 AMP_OUT_MUTE);
15166                 }
15167         }
15168 }
15169
15170 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
15171
15172 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
15173 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
15174
15175 /* add playback controls from the parsed DAC table */
15176 /* Based on ALC880 version. But ALC861VD has separate,
15177  * different NIDs for mute/unmute switch and volume control */
15178 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
15179                                              const struct auto_pin_cfg *cfg)
15180 {
15181         char name[32];
15182         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
15183         hda_nid_t nid_v, nid_s;
15184         int i, err;
15185
15186         for (i = 0; i < cfg->line_outs; i++) {
15187                 if (!spec->multiout.dac_nids[i])
15188                         continue;
15189                 nid_v = alc861vd_idx_to_mixer_vol(
15190                                 alc880_dac_to_idx(
15191                                         spec->multiout.dac_nids[i]));
15192                 nid_s = alc861vd_idx_to_mixer_switch(
15193                                 alc880_dac_to_idx(
15194                                         spec->multiout.dac_nids[i]));
15195
15196                 if (i == 2) {
15197                         /* Center/LFE */
15198                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
15199                                           "Center Playback Volume",
15200                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
15201                                                               HDA_OUTPUT));
15202                         if (err < 0)
15203                                 return err;
15204                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
15205                                           "LFE Playback Volume",
15206                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
15207                                                               HDA_OUTPUT));
15208                         if (err < 0)
15209                                 return err;
15210                         err = add_control(spec, ALC_CTL_BIND_MUTE,
15211                                           "Center Playback Switch",
15212                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
15213                                                               HDA_INPUT));
15214                         if (err < 0)
15215                                 return err;
15216                         err = add_control(spec, ALC_CTL_BIND_MUTE,
15217                                           "LFE Playback Switch",
15218                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
15219                                                               HDA_INPUT));
15220                         if (err < 0)
15221                                 return err;
15222                 } else {
15223                         sprintf(name, "%s Playback Volume", chname[i]);
15224                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
15225                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
15226                                                               HDA_OUTPUT));
15227                         if (err < 0)
15228                                 return err;
15229                         sprintf(name, "%s Playback Switch", chname[i]);
15230                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
15231                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
15232                                                               HDA_INPUT));
15233                         if (err < 0)
15234                                 return err;
15235                 }
15236         }
15237         return 0;
15238 }
15239
15240 /* add playback controls for speaker and HP outputs */
15241 /* Based on ALC880 version. But ALC861VD has separate,
15242  * different NIDs for mute/unmute switch and volume control */
15243 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
15244                                         hda_nid_t pin, const char *pfx)
15245 {
15246         hda_nid_t nid_v, nid_s;
15247         int err;
15248         char name[32];
15249
15250         if (!pin)
15251                 return 0;
15252
15253         if (alc880_is_fixed_pin(pin)) {
15254                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
15255                 /* specify the DAC as the extra output */
15256                 if (!spec->multiout.hp_nid)
15257                         spec->multiout.hp_nid = nid_v;
15258                 else
15259                         spec->multiout.extra_out_nid[0] = nid_v;
15260                 /* control HP volume/switch on the output mixer amp */
15261                 nid_v = alc861vd_idx_to_mixer_vol(
15262                                 alc880_fixed_pin_idx(pin));
15263                 nid_s = alc861vd_idx_to_mixer_switch(
15264                                 alc880_fixed_pin_idx(pin));
15265
15266                 sprintf(name, "%s Playback Volume", pfx);
15267                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
15268                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
15269                 if (err < 0)
15270                         return err;
15271                 sprintf(name, "%s Playback Switch", pfx);
15272                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
15273                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
15274                 if (err < 0)
15275                         return err;
15276         } else if (alc880_is_multi_pin(pin)) {
15277                 /* set manual connection */
15278                 /* we have only a switch on HP-out PIN */
15279                 sprintf(name, "%s Playback Switch", pfx);
15280                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
15281                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15282                 if (err < 0)
15283                         return err;
15284         }
15285         return 0;
15286 }
15287
15288 /* parse the BIOS configuration and set up the alc_spec
15289  * return 1 if successful, 0 if the proper config is not found,
15290  * or a negative error code
15291  * Based on ALC880 version - had to change it to override
15292  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15293 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15294 {
15295         struct alc_spec *spec = codec->spec;
15296         int err;
15297         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15298
15299         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15300                                            alc861vd_ignore);
15301         if (err < 0)
15302                 return err;
15303         if (!spec->autocfg.line_outs)
15304                 return 0; /* can't find valid BIOS pin config */
15305
15306         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15307         if (err < 0)
15308                 return err;
15309         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15310         if (err < 0)
15311                 return err;
15312         err = alc861vd_auto_create_extra_out(spec,
15313                                              spec->autocfg.speaker_pins[0],
15314                                              "Speaker");
15315         if (err < 0)
15316                 return err;
15317         err = alc861vd_auto_create_extra_out(spec,
15318                                              spec->autocfg.hp_pins[0],
15319                                              "Headphone");
15320         if (err < 0)
15321                 return err;
15322         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
15323         if (err < 0)
15324                 return err;
15325
15326         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15327
15328         if (spec->autocfg.dig_outs)
15329                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15330
15331         if (spec->kctls.list)
15332                 add_mixer(spec, spec->kctls.list);
15333
15334         add_verb(spec, alc861vd_volume_init_verbs);
15335
15336         spec->num_mux_defs = 1;
15337         spec->input_mux = &spec->private_imux[0];
15338
15339         err = alc_auto_add_mic_boost(codec);
15340         if (err < 0)
15341                 return err;
15342
15343         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
15344
15345         return 1;
15346 }
15347
15348 /* additional initialization for auto-configuration model */
15349 static void alc861vd_auto_init(struct hda_codec *codec)
15350 {
15351         struct alc_spec *spec = codec->spec;
15352         alc861vd_auto_init_multi_out(codec);
15353         alc861vd_auto_init_hp_out(codec);
15354         alc861vd_auto_init_analog_input(codec);
15355         alc861vd_auto_init_input_src(codec);
15356         if (spec->unsol_event)
15357                 alc_inithook(codec);
15358 }
15359
15360 static int patch_alc861vd(struct hda_codec *codec)
15361 {
15362         struct alc_spec *spec;
15363         int err, board_config;
15364
15365         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15366         if (spec == NULL)
15367                 return -ENOMEM;
15368
15369         codec->spec = spec;
15370
15371         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15372                                                   alc861vd_models,
15373                                                   alc861vd_cfg_tbl);
15374
15375         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15376                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
15377                        "trying auto-probe from BIOS...\n", codec->chip_name);
15378                 board_config = ALC861VD_AUTO;
15379         }
15380
15381         if (board_config == ALC861VD_AUTO) {
15382                 /* automatic parse from the BIOS config */
15383                 err = alc861vd_parse_auto_config(codec);
15384                 if (err < 0) {
15385                         alc_free(codec);
15386                         return err;
15387                 } else if (!err) {
15388                         printk(KERN_INFO
15389                                "hda_codec: Cannot set up configuration "
15390                                "from BIOS.  Using base mode...\n");
15391                         board_config = ALC861VD_3ST;
15392                 }
15393         }
15394
15395         err = snd_hda_attach_beep_device(codec, 0x23);
15396         if (err < 0) {
15397                 alc_free(codec);
15398                 return err;
15399         }
15400
15401         if (board_config != ALC861VD_AUTO)
15402                 setup_preset(spec, &alc861vd_presets[board_config]);
15403
15404         if (codec->vendor_id == 0x10ec0660) {
15405                 /* always turn on EAPD */
15406                 add_verb(spec, alc660vd_eapd_verbs);
15407         }
15408
15409         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15410         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15411
15412         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15413         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15414
15415         spec->adc_nids = alc861vd_adc_nids;
15416         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15417         spec->capsrc_nids = alc861vd_capsrc_nids;
15418
15419         set_capture_mixer(spec);
15420         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15421
15422         spec->vmaster_nid = 0x02;
15423
15424         codec->patch_ops = alc_patch_ops;
15425
15426         if (board_config == ALC861VD_AUTO)
15427                 spec->init_hook = alc861vd_auto_init;
15428 #ifdef CONFIG_SND_HDA_POWER_SAVE
15429         if (!spec->loopback.amplist)
15430                 spec->loopback.amplist = alc861vd_loopbacks;
15431 #endif
15432         codec->proc_widget_hook = print_realtek_coef;
15433
15434         return 0;
15435 }
15436
15437 /*
15438  * ALC662 support
15439  *
15440  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15441  * configuration.  Each pin widget can choose any input DACs and a mixer.
15442  * Each ADC is connected from a mixer of all inputs.  This makes possible
15443  * 6-channel independent captures.
15444  *
15445  * In addition, an independent DAC for the multi-playback (not used in this
15446  * driver yet).
15447  */
15448 #define ALC662_DIGOUT_NID       0x06
15449 #define ALC662_DIGIN_NID        0x0a
15450
15451 static hda_nid_t alc662_dac_nids[4] = {
15452         /* front, rear, clfe, rear_surr */
15453         0x02, 0x03, 0x04
15454 };
15455
15456 static hda_nid_t alc272_dac_nids[2] = {
15457         0x02, 0x03
15458 };
15459
15460 static hda_nid_t alc662_adc_nids[1] = {
15461         /* ADC1-2 */
15462         0x09,
15463 };
15464
15465 static hda_nid_t alc272_adc_nids[1] = {
15466         /* ADC1-2 */
15467         0x08,
15468 };
15469
15470 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
15471 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
15472
15473
15474 /* input MUX */
15475 /* FIXME: should be a matrix-type input source selection */
15476 static struct hda_input_mux alc662_capture_source = {
15477         .num_items = 4,
15478         .items = {
15479                 { "Mic", 0x0 },
15480                 { "Front Mic", 0x1 },
15481                 { "Line", 0x2 },
15482                 { "CD", 0x4 },
15483         },
15484 };
15485
15486 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15487         .num_items = 2,
15488         .items = {
15489                 { "Mic", 0x1 },
15490                 { "Line", 0x2 },
15491         },
15492 };
15493
15494 static struct hda_input_mux alc662_eeepc_capture_source = {
15495         .num_items = 2,
15496         .items = {
15497                 { "i-Mic", 0x1 },
15498                 { "e-Mic", 0x0 },
15499         },
15500 };
15501
15502 static struct hda_input_mux alc663_capture_source = {
15503         .num_items = 3,
15504         .items = {
15505                 { "Mic", 0x0 },
15506                 { "Front Mic", 0x1 },
15507                 { "Line", 0x2 },
15508         },
15509 };
15510
15511 static struct hda_input_mux alc663_m51va_capture_source = {
15512         .num_items = 2,
15513         .items = {
15514                 { "Ext-Mic", 0x0 },
15515                 { "D-Mic", 0x9 },
15516         },
15517 };
15518
15519 #if 1 /* set to 0 for testing other input sources below */
15520 static struct hda_input_mux alc272_nc10_capture_source = {
15521         .num_items = 2,
15522         .items = {
15523                 { "Autoselect Mic", 0x0 },
15524                 { "Internal Mic", 0x1 },
15525         },
15526 };
15527 #else
15528 static struct hda_input_mux alc272_nc10_capture_source = {
15529         .num_items = 16,
15530         .items = {
15531                 { "Autoselect Mic", 0x0 },
15532                 { "Internal Mic", 0x1 },
15533                 { "In-0x02", 0x2 },
15534                 { "In-0x03", 0x3 },
15535                 { "In-0x04", 0x4 },
15536                 { "In-0x05", 0x5 },
15537                 { "In-0x06", 0x6 },
15538                 { "In-0x07", 0x7 },
15539                 { "In-0x08", 0x8 },
15540                 { "In-0x09", 0x9 },
15541                 { "In-0x0a", 0x0a },
15542                 { "In-0x0b", 0x0b },
15543                 { "In-0x0c", 0x0c },
15544                 { "In-0x0d", 0x0d },
15545                 { "In-0x0e", 0x0e },
15546                 { "In-0x0f", 0x0f },
15547         },
15548 };
15549 #endif
15550
15551 /*
15552  * 2ch mode
15553  */
15554 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15555         { 2, NULL }
15556 };
15557
15558 /*
15559  * 2ch mode
15560  */
15561 static struct hda_verb alc662_3ST_ch2_init[] = {
15562         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15563         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15564         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15565         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15566         { } /* end */
15567 };
15568
15569 /*
15570  * 6ch mode
15571  */
15572 static struct hda_verb alc662_3ST_ch6_init[] = {
15573         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15574         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15575         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15576         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15577         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15578         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15579         { } /* end */
15580 };
15581
15582 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15583         { 2, alc662_3ST_ch2_init },
15584         { 6, alc662_3ST_ch6_init },
15585 };
15586
15587 /*
15588  * 2ch mode
15589  */
15590 static struct hda_verb alc662_sixstack_ch6_init[] = {
15591         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15592         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15593         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15594         { } /* end */
15595 };
15596
15597 /*
15598  * 6ch mode
15599  */
15600 static struct hda_verb alc662_sixstack_ch8_init[] = {
15601         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15602         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15603         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15604         { } /* end */
15605 };
15606
15607 static struct hda_channel_mode alc662_5stack_modes[2] = {
15608         { 2, alc662_sixstack_ch6_init },
15609         { 6, alc662_sixstack_ch8_init },
15610 };
15611
15612 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15613  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15614  */
15615
15616 static struct snd_kcontrol_new alc662_base_mixer[] = {
15617         /* output mixer control */
15618         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
15619         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15620         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
15621         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15622         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15623         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15624         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15625         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15626         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15627
15628         /*Input mixer control */
15629         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
15630         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
15631         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
15632         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
15633         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
15634         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
15635         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
15636         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
15637         { } /* end */
15638 };
15639
15640 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
15641         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15642         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15643         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15644         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15645         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15646         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15647         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15648         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15649         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15650         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15651         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15652         { } /* end */
15653 };
15654
15655 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
15656         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15657         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15658         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15659         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15660         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15661         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15662         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15663         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15664         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15665         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15666         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15667         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15668         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15669         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15670         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15671         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15672         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15673         { } /* end */
15674 };
15675
15676 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
15677         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15678         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
15679         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15680         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
15681         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15682         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15683         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15684         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15685         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15686         { } /* end */
15687 };
15688
15689 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
15690         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15691         ALC262_HIPPO_MASTER_SWITCH,
15692
15693         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
15694         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15695         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15696
15697         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15698         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15699         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15700         { } /* end */
15701 };
15702
15703 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
15704         ALC262_HIPPO_MASTER_SWITCH,
15705         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15706         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15707         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15708         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15709         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
15710         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15711         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15712         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15713         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15714         { } /* end */
15715 };
15716
15717 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
15718         .ops = &snd_hda_bind_vol,
15719         .values = {
15720                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15721                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
15722                 0
15723         },
15724 };
15725
15726 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
15727         .ops = &snd_hda_bind_sw,
15728         .values = {
15729                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15730                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15731                 0
15732         },
15733 };
15734
15735 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
15736         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15737         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
15738         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15739         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15740         { } /* end */
15741 };
15742
15743 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
15744         .ops = &snd_hda_bind_sw,
15745         .values = {
15746                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15747                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15748                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15749                 0
15750         },
15751 };
15752
15753 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
15754         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15755         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
15756         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15757         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15758         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15759         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15760
15761         { } /* end */
15762 };
15763
15764 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
15765         .ops = &snd_hda_bind_sw,
15766         .values = {
15767                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15768                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15769                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15770                 0
15771         },
15772 };
15773
15774 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
15775         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15776         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
15777         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15778         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15779         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15780         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15781         { } /* end */
15782 };
15783
15784 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
15785         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15786         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15787         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15788         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15789         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15790         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15791         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15792         { } /* end */
15793 };
15794
15795 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
15796         .ops = &snd_hda_bind_vol,
15797         .values = {
15798                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15799                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
15800                 0
15801         },
15802 };
15803
15804 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
15805         .ops = &snd_hda_bind_sw,
15806         .values = {
15807                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15808                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
15809                 0
15810         },
15811 };
15812
15813 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
15814         HDA_BIND_VOL("Master Playback Volume",
15815                                 &alc663_asus_two_bind_master_vol),
15816         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15817         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15818         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15819         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15820         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15821         { } /* end */
15822 };
15823
15824 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
15825         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15826         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15827         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15828         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15829         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15830         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15831         { } /* end */
15832 };
15833
15834 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
15835         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15836         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15837         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15838         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15839         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15840
15841         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15842         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15843         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15844         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15845         { } /* end */
15846 };
15847
15848 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
15849         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15850         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15851         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15852
15853         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15854         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15855         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15856         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15857         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15858         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15859         { } /* end */
15860 };
15861
15862 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
15863         {
15864                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15865                 .name = "Channel Mode",
15866                 .info = alc_ch_mode_info,
15867                 .get = alc_ch_mode_get,
15868                 .put = alc_ch_mode_put,
15869         },
15870         { } /* end */
15871 };
15872
15873 static struct hda_verb alc662_init_verbs[] = {
15874         /* ADC: mute amp left and right */
15875         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15876         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15877         /* Front mixer: unmute input/output amp left and right (volume = 0) */
15878
15879         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15880         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15881         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15882         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15883         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15884
15885         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15886         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15887         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15888         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15889         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15890         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15891
15892         /* Front Pin: output 0 (0x0c) */
15893         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15894         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15895
15896         /* Rear Pin: output 1 (0x0d) */
15897         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15898         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15899
15900         /* CLFE Pin: output 2 (0x0e) */
15901         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15902         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15903
15904         /* Mic (rear) pin: input vref at 80% */
15905         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15906         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15907         /* Front Mic pin: input vref at 80% */
15908         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15909         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15910         /* Line In pin: input */
15911         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15912         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15913         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15914         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15915         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15916         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15917         /* CD pin widget for input */
15918         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15919
15920         /* FIXME: use matrix-type input source selection */
15921         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15922         /* Input mixer */
15923         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15924         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15925
15926         /* always trun on EAPD */
15927         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15928         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15929
15930         { }
15931 };
15932
15933 static struct hda_verb alc662_sue_init_verbs[] = {
15934         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15935         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15936         {}
15937 };
15938
15939 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
15940         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15941         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15942         {}
15943 };
15944
15945 /* Set Unsolicited Event*/
15946 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15947         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15948         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15949         {}
15950 };
15951
15952 /*
15953  * generic initialization of ADC, input mixers and output mixers
15954  */
15955 static struct hda_verb alc662_auto_init_verbs[] = {
15956         /*
15957          * Unmute ADC and set the default input to mic-in
15958          */
15959         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15960         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15961
15962         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15963          * mixer widget
15964          * Note: PASD motherboards uses the Line In 2 as the input for front
15965          * panel mic (mic 2)
15966          */
15967         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15968         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15969         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15970         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15971         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15972         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15973
15974         /*
15975          * Set up output mixers (0x0c - 0x0f)
15976          */
15977         /* set vol=0 to output mixers */
15978         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15979         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15980         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15981
15982         /* set up input amps for analog loopback */
15983         /* Amp Indices: DAC = 0, mixer = 1 */
15984         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15985         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15986         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15987         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15988         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15989         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15990
15991
15992         /* FIXME: use matrix-type input source selection */
15993         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15994         /* Input mixer */
15995         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15996         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15997         { }
15998 };
15999
16000 /* additional verbs for ALC663 */
16001 static struct hda_verb alc663_auto_init_verbs[] = {
16002         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16003         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16004         { }
16005 };
16006
16007 static struct hda_verb alc663_m51va_init_verbs[] = {
16008         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16009         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16010         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16011         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16012         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16013         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16014         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16015         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16016         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16017         {}
16018 };
16019
16020 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
16021         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16022         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16023         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16024         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16025         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16026         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16027         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16028         {}
16029 };
16030
16031 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
16032         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16033         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16034         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16035         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16036         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16037         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16038         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16039         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16040         {}
16041 };
16042
16043 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
16044         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16045         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16046         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16047         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16048         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16049         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16050         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16051         {}
16052 };
16053
16054 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
16055         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16056         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16057         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16058         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16059         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16060         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16061         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16062         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16063         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16064         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16065         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16066         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16067         {}
16068 };
16069
16070 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
16071         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16072         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16073         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16074         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16075         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16076         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16077         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16078         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16079         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16080         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16081         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16082         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16083         {}
16084 };
16085
16086 static struct hda_verb alc663_g71v_init_verbs[] = {
16087         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16088         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
16089         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
16090
16091         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16092         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16093         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16094
16095         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16096         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
16097         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16098         {}
16099 };
16100
16101 static struct hda_verb alc663_g50v_init_verbs[] = {
16102         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16103         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16104         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16105
16106         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16107         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16108         {}
16109 };
16110
16111 static struct hda_verb alc662_ecs_init_verbs[] = {
16112         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
16113         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16114         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16115         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16116         {}
16117 };
16118
16119 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
16120         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16121         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16122         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16123         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16124         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16125         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16126         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16127         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16128         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16129         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16130         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16131         {}
16132 };
16133
16134 static struct hda_verb alc272_dell_init_verbs[] = {
16135         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16136         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16137         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16138         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16139         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16140         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16141         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16142         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16143         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16144         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16145         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16146         {}
16147 };
16148
16149 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
16150         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
16151         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
16152         { } /* end */
16153 };
16154
16155 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
16156         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
16157         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
16158         { } /* end */
16159 };
16160
16161 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
16162 {
16163         unsigned int present;
16164         unsigned char bits;
16165
16166         present = snd_hda_codec_read(codec, 0x14, 0,
16167                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
16168         bits = present ? HDA_AMP_MUTE : 0;
16169         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16170                                  HDA_AMP_MUTE, bits);
16171 }
16172
16173 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
16174 {
16175         unsigned int present;
16176         unsigned char bits;
16177
16178         present = snd_hda_codec_read(codec, 0x1b, 0,
16179                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
16180         bits = present ? HDA_AMP_MUTE : 0;
16181         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16182                                  HDA_AMP_MUTE, bits);
16183         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16184                                  HDA_AMP_MUTE, bits);
16185 }
16186
16187 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
16188                                            unsigned int res)
16189 {
16190         if ((res >> 26) == ALC880_HP_EVENT)
16191                 alc662_lenovo_101e_all_automute(codec);
16192         if ((res >> 26) == ALC880_FRONT_EVENT)
16193                 alc662_lenovo_101e_ispeaker_automute(codec);
16194 }
16195
16196 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
16197 {
16198         unsigned int present;
16199
16200         present = snd_hda_codec_read(codec, 0x18, 0,
16201                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
16202         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16203                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16204         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16205                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16206         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16207                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
16208         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16209                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
16210 }
16211
16212 /* unsolicited event for HP jack sensing */
16213 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
16214                                      unsigned int res)
16215 {
16216         if ((res >> 26) == ALC880_MIC_EVENT)
16217                 alc662_eeepc_mic_automute(codec);
16218         else
16219                 alc262_hippo_unsol_event(codec, res);
16220 }
16221
16222 static void alc662_eeepc_inithook(struct hda_codec *codec)
16223 {
16224         alc262_hippo1_init_hook(codec);
16225         alc662_eeepc_mic_automute(codec);
16226 }
16227
16228 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
16229 {
16230         struct alc_spec *spec = codec->spec;
16231
16232         spec->autocfg.hp_pins[0] = 0x14;
16233         spec->autocfg.speaker_pins[0] = 0x1b;
16234         alc262_hippo_master_update(codec);
16235 }
16236
16237 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
16238 {
16239         unsigned int present;
16240         unsigned char bits;
16241
16242         present = snd_hda_codec_read(codec, 0x21, 0,
16243                         AC_VERB_GET_PIN_SENSE, 0)
16244                         & AC_PINSENSE_PRESENCE;
16245         bits = present ? HDA_AMP_MUTE : 0;
16246         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16247                                 AMP_IN_MUTE(0), bits);
16248         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16249                                 AMP_IN_MUTE(0), bits);
16250 }
16251
16252 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
16253 {
16254         unsigned int present;
16255         unsigned char bits;
16256
16257         present = snd_hda_codec_read(codec, 0x21, 0,
16258                         AC_VERB_GET_PIN_SENSE, 0)
16259                         & AC_PINSENSE_PRESENCE;
16260         bits = present ? HDA_AMP_MUTE : 0;
16261         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16262                                 AMP_IN_MUTE(0), bits);
16263         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16264                                 AMP_IN_MUTE(0), bits);
16265         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16266                                 AMP_IN_MUTE(0), bits);
16267         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16268                                 AMP_IN_MUTE(0), bits);
16269 }
16270
16271 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
16272 {
16273         unsigned int present;
16274         unsigned char bits;
16275
16276         present = snd_hda_codec_read(codec, 0x15, 0,
16277                         AC_VERB_GET_PIN_SENSE, 0)
16278                         & AC_PINSENSE_PRESENCE;
16279         bits = present ? HDA_AMP_MUTE : 0;
16280         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16281                                 AMP_IN_MUTE(0), bits);
16282         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16283                                 AMP_IN_MUTE(0), bits);
16284         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16285                                 AMP_IN_MUTE(0), bits);
16286         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16287                                 AMP_IN_MUTE(0), bits);
16288 }
16289
16290 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
16291 {
16292         unsigned int present;
16293         unsigned char bits;
16294
16295         present = snd_hda_codec_read(codec, 0x1b, 0,
16296                         AC_VERB_GET_PIN_SENSE, 0)
16297                         & AC_PINSENSE_PRESENCE;
16298         bits = present ? 0 : PIN_OUT;
16299         snd_hda_codec_write(codec, 0x14, 0,
16300                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
16301 }
16302
16303 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
16304 {
16305         unsigned int present1, present2;
16306
16307         present1 = snd_hda_codec_read(codec, 0x21, 0,
16308                         AC_VERB_GET_PIN_SENSE, 0)
16309                         & AC_PINSENSE_PRESENCE;
16310         present2 = snd_hda_codec_read(codec, 0x15, 0,
16311                         AC_VERB_GET_PIN_SENSE, 0)
16312                         & AC_PINSENSE_PRESENCE;
16313
16314         if (present1 || present2) {
16315                 snd_hda_codec_write_cache(codec, 0x14, 0,
16316                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16317         } else {
16318                 snd_hda_codec_write_cache(codec, 0x14, 0,
16319                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16320         }
16321 }
16322
16323 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16324 {
16325         unsigned int present1, present2;
16326
16327         present1 = snd_hda_codec_read(codec, 0x1b, 0,
16328                                 AC_VERB_GET_PIN_SENSE, 0)
16329                                 & AC_PINSENSE_PRESENCE;
16330         present2 = snd_hda_codec_read(codec, 0x15, 0,
16331                                 AC_VERB_GET_PIN_SENSE, 0)
16332                                 & AC_PINSENSE_PRESENCE;
16333
16334         if (present1 || present2) {
16335                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16336                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16337                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16338                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16339         } else {
16340                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16341                                 AMP_IN_MUTE(0), 0);
16342                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16343                                 AMP_IN_MUTE(0), 0);
16344         }
16345 }
16346
16347 static void alc663_m51va_mic_automute(struct hda_codec *codec)
16348 {
16349         unsigned int present;
16350
16351         present = snd_hda_codec_read(codec, 0x18, 0,
16352                         AC_VERB_GET_PIN_SENSE, 0)
16353                         & AC_PINSENSE_PRESENCE;
16354         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16355                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16356         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16357                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16358         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16359                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16360         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16361                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16362 }
16363
16364 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16365                                            unsigned int res)
16366 {
16367         switch (res >> 26) {
16368         case ALC880_HP_EVENT:
16369                 alc663_m51va_speaker_automute(codec);
16370                 break;
16371         case ALC880_MIC_EVENT:
16372                 alc663_m51va_mic_automute(codec);
16373                 break;
16374         }
16375 }
16376
16377 static void alc663_m51va_inithook(struct hda_codec *codec)
16378 {
16379         alc663_m51va_speaker_automute(codec);
16380         alc663_m51va_mic_automute(codec);
16381 }
16382
16383 /* ***************** Mode1 ******************************/
16384 static void alc663_mode1_unsol_event(struct hda_codec *codec,
16385                                            unsigned int res)
16386 {
16387         switch (res >> 26) {
16388         case ALC880_HP_EVENT:
16389                 alc663_m51va_speaker_automute(codec);
16390                 break;
16391         case ALC880_MIC_EVENT:
16392                 alc662_eeepc_mic_automute(codec);
16393                 break;
16394         }
16395 }
16396
16397 static void alc663_mode1_inithook(struct hda_codec *codec)
16398 {
16399         alc663_m51va_speaker_automute(codec);
16400         alc662_eeepc_mic_automute(codec);
16401 }
16402 /* ***************** Mode2 ******************************/
16403 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16404                                            unsigned int res)
16405 {
16406         switch (res >> 26) {
16407         case ALC880_HP_EVENT:
16408                 alc662_f5z_speaker_automute(codec);
16409                 break;
16410         case ALC880_MIC_EVENT:
16411                 alc662_eeepc_mic_automute(codec);
16412                 break;
16413         }
16414 }
16415
16416 static void alc662_mode2_inithook(struct hda_codec *codec)
16417 {
16418         alc662_f5z_speaker_automute(codec);
16419         alc662_eeepc_mic_automute(codec);
16420 }
16421 /* ***************** Mode3 ******************************/
16422 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16423                                            unsigned int res)
16424 {
16425         switch (res >> 26) {
16426         case ALC880_HP_EVENT:
16427                 alc663_two_hp_m1_speaker_automute(codec);
16428                 break;
16429         case ALC880_MIC_EVENT:
16430                 alc662_eeepc_mic_automute(codec);
16431                 break;
16432         }
16433 }
16434
16435 static void alc663_mode3_inithook(struct hda_codec *codec)
16436 {
16437         alc663_two_hp_m1_speaker_automute(codec);
16438         alc662_eeepc_mic_automute(codec);
16439 }
16440 /* ***************** Mode4 ******************************/
16441 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16442                                            unsigned int res)
16443 {
16444         switch (res >> 26) {
16445         case ALC880_HP_EVENT:
16446                 alc663_21jd_two_speaker_automute(codec);
16447                 break;
16448         case ALC880_MIC_EVENT:
16449                 alc662_eeepc_mic_automute(codec);
16450                 break;
16451         }
16452 }
16453
16454 static void alc663_mode4_inithook(struct hda_codec *codec)
16455 {
16456         alc663_21jd_two_speaker_automute(codec);
16457         alc662_eeepc_mic_automute(codec);
16458 }
16459 /* ***************** Mode5 ******************************/
16460 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16461                                            unsigned int res)
16462 {
16463         switch (res >> 26) {
16464         case ALC880_HP_EVENT:
16465                 alc663_15jd_two_speaker_automute(codec);
16466                 break;
16467         case ALC880_MIC_EVENT:
16468                 alc662_eeepc_mic_automute(codec);
16469                 break;
16470         }
16471 }
16472
16473 static void alc663_mode5_inithook(struct hda_codec *codec)
16474 {
16475         alc663_15jd_two_speaker_automute(codec);
16476         alc662_eeepc_mic_automute(codec);
16477 }
16478 /* ***************** Mode6 ******************************/
16479 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16480                                            unsigned int res)
16481 {
16482         switch (res >> 26) {
16483         case ALC880_HP_EVENT:
16484                 alc663_two_hp_m2_speaker_automute(codec);
16485                 break;
16486         case ALC880_MIC_EVENT:
16487                 alc662_eeepc_mic_automute(codec);
16488                 break;
16489         }
16490 }
16491
16492 static void alc663_mode6_inithook(struct hda_codec *codec)
16493 {
16494         alc663_two_hp_m2_speaker_automute(codec);
16495         alc662_eeepc_mic_automute(codec);
16496 }
16497
16498 static void alc663_g71v_hp_automute(struct hda_codec *codec)
16499 {
16500         unsigned int present;
16501         unsigned char bits;
16502
16503         present = snd_hda_codec_read(codec, 0x21, 0,
16504                                      AC_VERB_GET_PIN_SENSE, 0)
16505                 & AC_PINSENSE_PRESENCE;
16506         bits = present ? HDA_AMP_MUTE : 0;
16507         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16508                                  HDA_AMP_MUTE, bits);
16509         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16510                                  HDA_AMP_MUTE, bits);
16511 }
16512
16513 static void alc663_g71v_front_automute(struct hda_codec *codec)
16514 {
16515         unsigned int present;
16516         unsigned char bits;
16517
16518         present = snd_hda_codec_read(codec, 0x15, 0,
16519                                      AC_VERB_GET_PIN_SENSE, 0)
16520                 & AC_PINSENSE_PRESENCE;
16521         bits = present ? HDA_AMP_MUTE : 0;
16522         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16523                                  HDA_AMP_MUTE, bits);
16524 }
16525
16526 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16527                                            unsigned int res)
16528 {
16529         switch (res >> 26) {
16530         case ALC880_HP_EVENT:
16531                 alc663_g71v_hp_automute(codec);
16532                 break;
16533         case ALC880_FRONT_EVENT:
16534                 alc663_g71v_front_automute(codec);
16535                 break;
16536         case ALC880_MIC_EVENT:
16537                 alc662_eeepc_mic_automute(codec);
16538                 break;
16539         }
16540 }
16541
16542 static void alc663_g71v_inithook(struct hda_codec *codec)
16543 {
16544         alc663_g71v_front_automute(codec);
16545         alc663_g71v_hp_automute(codec);
16546         alc662_eeepc_mic_automute(codec);
16547 }
16548
16549 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16550                                            unsigned int res)
16551 {
16552         switch (res >> 26) {
16553         case ALC880_HP_EVENT:
16554                 alc663_m51va_speaker_automute(codec);
16555                 break;
16556         case ALC880_MIC_EVENT:
16557                 alc662_eeepc_mic_automute(codec);
16558                 break;
16559         }
16560 }
16561
16562 static void alc663_g50v_inithook(struct hda_codec *codec)
16563 {
16564         alc663_m51va_speaker_automute(codec);
16565         alc662_eeepc_mic_automute(codec);
16566 }
16567
16568 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16569         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16570         ALC262_HIPPO_MASTER_SWITCH,
16571
16572         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16573         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16574         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16575
16576         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16577         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16578         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16579         { } /* end */
16580 };
16581
16582 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
16583         /* Master Playback automatically created from Speaker and Headphone */
16584         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16585         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16586         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16587         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16588
16589         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16590         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16591         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
16592
16593         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16594         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16595         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
16596         { } /* end */
16597 };
16598
16599 #ifdef CONFIG_SND_HDA_POWER_SAVE
16600 #define alc662_loopbacks        alc880_loopbacks
16601 #endif
16602
16603
16604 /* pcm configuration: identical with ALC880 */
16605 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
16606 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
16607 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
16608 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
16609
16610 /*
16611  * configuration and preset
16612  */
16613 static const char *alc662_models[ALC662_MODEL_LAST] = {
16614         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
16615         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
16616         [ALC662_3ST_6ch]        = "3stack-6ch",
16617         [ALC662_5ST_DIG]        = "6stack-dig",
16618         [ALC662_LENOVO_101E]    = "lenovo-101e",
16619         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
16620         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
16621         [ALC662_ECS] = "ecs",
16622         [ALC663_ASUS_M51VA] = "m51va",
16623         [ALC663_ASUS_G71V] = "g71v",
16624         [ALC663_ASUS_H13] = "h13",
16625         [ALC663_ASUS_G50V] = "g50v",
16626         [ALC663_ASUS_MODE1] = "asus-mode1",
16627         [ALC662_ASUS_MODE2] = "asus-mode2",
16628         [ALC663_ASUS_MODE3] = "asus-mode3",
16629         [ALC663_ASUS_MODE4] = "asus-mode4",
16630         [ALC663_ASUS_MODE5] = "asus-mode5",
16631         [ALC663_ASUS_MODE6] = "asus-mode6",
16632         [ALC272_DELL]           = "dell",
16633         [ALC272_DELL_ZM1]       = "dell-zm1",
16634         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
16635         [ALC662_AUTO]           = "auto",
16636 };
16637
16638 static struct snd_pci_quirk alc662_cfg_tbl[] = {
16639         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
16640         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
16641         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
16642         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
16643         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
16644         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
16645         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
16646         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
16647         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
16648         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
16649         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
16650         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
16651         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
16652         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
16653         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
16654         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
16655         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
16656         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
16657         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
16658         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
16659         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
16660         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
16661         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
16662         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
16663         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
16664         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
16665         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
16666         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
16667         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
16668         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
16669         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
16670         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
16671         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
16672         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
16673         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
16674         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
16675         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
16676         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
16677         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
16678         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
16679         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
16680         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
16681         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
16682         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
16683         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
16684         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
16685         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
16686         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
16687         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
16688         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
16689         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
16690         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
16691                       ALC662_3ST_6ch_DIG),
16692         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
16693         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
16694                       ALC662_3ST_6ch_DIG),
16695         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
16696         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
16697         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
16698         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
16699                                         ALC662_3ST_6ch_DIG),
16700         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
16701                            ALC663_ASUS_H13),
16702         {}
16703 };
16704
16705 static struct alc_config_preset alc662_presets[] = {
16706         [ALC662_3ST_2ch_DIG] = {
16707                 .mixers = { alc662_3ST_2ch_mixer },
16708                 .init_verbs = { alc662_init_verbs },
16709                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16710                 .dac_nids = alc662_dac_nids,
16711                 .dig_out_nid = ALC662_DIGOUT_NID,
16712                 .dig_in_nid = ALC662_DIGIN_NID,
16713                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16714                 .channel_mode = alc662_3ST_2ch_modes,
16715                 .input_mux = &alc662_capture_source,
16716         },
16717         [ALC662_3ST_6ch_DIG] = {
16718                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16719                 .init_verbs = { alc662_init_verbs },
16720                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16721                 .dac_nids = alc662_dac_nids,
16722                 .dig_out_nid = ALC662_DIGOUT_NID,
16723                 .dig_in_nid = ALC662_DIGIN_NID,
16724                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16725                 .channel_mode = alc662_3ST_6ch_modes,
16726                 .need_dac_fix = 1,
16727                 .input_mux = &alc662_capture_source,
16728         },
16729         [ALC662_3ST_6ch] = {
16730                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16731                 .init_verbs = { alc662_init_verbs },
16732                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16733                 .dac_nids = alc662_dac_nids,
16734                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16735                 .channel_mode = alc662_3ST_6ch_modes,
16736                 .need_dac_fix = 1,
16737                 .input_mux = &alc662_capture_source,
16738         },
16739         [ALC662_5ST_DIG] = {
16740                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
16741                 .init_verbs = { alc662_init_verbs },
16742                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16743                 .dac_nids = alc662_dac_nids,
16744                 .dig_out_nid = ALC662_DIGOUT_NID,
16745                 .dig_in_nid = ALC662_DIGIN_NID,
16746                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
16747                 .channel_mode = alc662_5stack_modes,
16748                 .input_mux = &alc662_capture_source,
16749         },
16750         [ALC662_LENOVO_101E] = {
16751                 .mixers = { alc662_lenovo_101e_mixer },
16752                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
16753                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16754                 .dac_nids = alc662_dac_nids,
16755                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16756                 .channel_mode = alc662_3ST_2ch_modes,
16757                 .input_mux = &alc662_lenovo_101e_capture_source,
16758                 .unsol_event = alc662_lenovo_101e_unsol_event,
16759                 .init_hook = alc662_lenovo_101e_all_automute,
16760         },
16761         [ALC662_ASUS_EEEPC_P701] = {
16762                 .mixers = { alc662_eeepc_p701_mixer },
16763                 .init_verbs = { alc662_init_verbs,
16764                                 alc662_eeepc_sue_init_verbs },
16765                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16766                 .dac_nids = alc662_dac_nids,
16767                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16768                 .channel_mode = alc662_3ST_2ch_modes,
16769                 .input_mux = &alc662_eeepc_capture_source,
16770                 .unsol_event = alc662_eeepc_unsol_event,
16771                 .init_hook = alc662_eeepc_inithook,
16772         },
16773         [ALC662_ASUS_EEEPC_EP20] = {
16774                 .mixers = { alc662_eeepc_ep20_mixer,
16775                             alc662_chmode_mixer },
16776                 .init_verbs = { alc662_init_verbs,
16777                                 alc662_eeepc_ep20_sue_init_verbs },
16778                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16779                 .dac_nids = alc662_dac_nids,
16780                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16781                 .channel_mode = alc662_3ST_6ch_modes,
16782                 .input_mux = &alc662_lenovo_101e_capture_source,
16783                 .unsol_event = alc662_eeepc_unsol_event,
16784                 .init_hook = alc662_eeepc_ep20_inithook,
16785         },
16786         [ALC662_ECS] = {
16787                 .mixers = { alc662_ecs_mixer },
16788                 .init_verbs = { alc662_init_verbs,
16789                                 alc662_ecs_init_verbs },
16790                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16791                 .dac_nids = alc662_dac_nids,
16792                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16793                 .channel_mode = alc662_3ST_2ch_modes,
16794                 .input_mux = &alc662_eeepc_capture_source,
16795                 .unsol_event = alc662_eeepc_unsol_event,
16796                 .init_hook = alc662_eeepc_inithook,
16797         },
16798         [ALC663_ASUS_M51VA] = {
16799                 .mixers = { alc663_m51va_mixer },
16800                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16801                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16802                 .dac_nids = alc662_dac_nids,
16803                 .dig_out_nid = ALC662_DIGOUT_NID,
16804                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16805                 .channel_mode = alc662_3ST_2ch_modes,
16806                 .input_mux = &alc663_m51va_capture_source,
16807                 .unsol_event = alc663_m51va_unsol_event,
16808                 .init_hook = alc663_m51va_inithook,
16809         },
16810         [ALC663_ASUS_G71V] = {
16811                 .mixers = { alc663_g71v_mixer },
16812                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
16813                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16814                 .dac_nids = alc662_dac_nids,
16815                 .dig_out_nid = ALC662_DIGOUT_NID,
16816                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16817                 .channel_mode = alc662_3ST_2ch_modes,
16818                 .input_mux = &alc662_eeepc_capture_source,
16819                 .unsol_event = alc663_g71v_unsol_event,
16820                 .init_hook = alc663_g71v_inithook,
16821         },
16822         [ALC663_ASUS_H13] = {
16823                 .mixers = { alc663_m51va_mixer },
16824                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16825                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16826                 .dac_nids = alc662_dac_nids,
16827                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16828                 .channel_mode = alc662_3ST_2ch_modes,
16829                 .input_mux = &alc663_m51va_capture_source,
16830                 .unsol_event = alc663_m51va_unsol_event,
16831                 .init_hook = alc663_m51va_inithook,
16832         },
16833         [ALC663_ASUS_G50V] = {
16834                 .mixers = { alc663_g50v_mixer },
16835                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
16836                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16837                 .dac_nids = alc662_dac_nids,
16838                 .dig_out_nid = ALC662_DIGOUT_NID,
16839                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16840                 .channel_mode = alc662_3ST_6ch_modes,
16841                 .input_mux = &alc663_capture_source,
16842                 .unsol_event = alc663_g50v_unsol_event,
16843                 .init_hook = alc663_g50v_inithook,
16844         },
16845         [ALC663_ASUS_MODE1] = {
16846                 .mixers = { alc663_m51va_mixer },
16847                 .cap_mixer = alc662_auto_capture_mixer,
16848                 .init_verbs = { alc662_init_verbs,
16849                                 alc663_21jd_amic_init_verbs },
16850                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16851                 .hp_nid = 0x03,
16852                 .dac_nids = alc662_dac_nids,
16853                 .dig_out_nid = ALC662_DIGOUT_NID,
16854                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16855                 .channel_mode = alc662_3ST_2ch_modes,
16856                 .input_mux = &alc662_eeepc_capture_source,
16857                 .unsol_event = alc663_mode1_unsol_event,
16858                 .init_hook = alc663_mode1_inithook,
16859         },
16860         [ALC662_ASUS_MODE2] = {
16861                 .mixers = { alc662_1bjd_mixer },
16862                 .cap_mixer = alc662_auto_capture_mixer,
16863                 .init_verbs = { alc662_init_verbs,
16864                                 alc662_1bjd_amic_init_verbs },
16865                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16866                 .dac_nids = alc662_dac_nids,
16867                 .dig_out_nid = ALC662_DIGOUT_NID,
16868                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16869                 .channel_mode = alc662_3ST_2ch_modes,
16870                 .input_mux = &alc662_eeepc_capture_source,
16871                 .unsol_event = alc662_mode2_unsol_event,
16872                 .init_hook = alc662_mode2_inithook,
16873         },
16874         [ALC663_ASUS_MODE3] = {
16875                 .mixers = { alc663_two_hp_m1_mixer },
16876                 .cap_mixer = alc662_auto_capture_mixer,
16877                 .init_verbs = { alc662_init_verbs,
16878                                 alc663_two_hp_amic_m1_init_verbs },
16879                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16880                 .hp_nid = 0x03,
16881                 .dac_nids = alc662_dac_nids,
16882                 .dig_out_nid = ALC662_DIGOUT_NID,
16883                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16884                 .channel_mode = alc662_3ST_2ch_modes,
16885                 .input_mux = &alc662_eeepc_capture_source,
16886                 .unsol_event = alc663_mode3_unsol_event,
16887                 .init_hook = alc663_mode3_inithook,
16888         },
16889         [ALC663_ASUS_MODE4] = {
16890                 .mixers = { alc663_asus_21jd_clfe_mixer },
16891                 .cap_mixer = alc662_auto_capture_mixer,
16892                 .init_verbs = { alc662_init_verbs,
16893                                 alc663_21jd_amic_init_verbs},
16894                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16895                 .hp_nid = 0x03,
16896                 .dac_nids = alc662_dac_nids,
16897                 .dig_out_nid = ALC662_DIGOUT_NID,
16898                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16899                 .channel_mode = alc662_3ST_2ch_modes,
16900                 .input_mux = &alc662_eeepc_capture_source,
16901                 .unsol_event = alc663_mode4_unsol_event,
16902                 .init_hook = alc663_mode4_inithook,
16903         },
16904         [ALC663_ASUS_MODE5] = {
16905                 .mixers = { alc663_asus_15jd_clfe_mixer },
16906                 .cap_mixer = alc662_auto_capture_mixer,
16907                 .init_verbs = { alc662_init_verbs,
16908                                 alc663_15jd_amic_init_verbs },
16909                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16910                 .hp_nid = 0x03,
16911                 .dac_nids = alc662_dac_nids,
16912                 .dig_out_nid = ALC662_DIGOUT_NID,
16913                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16914                 .channel_mode = alc662_3ST_2ch_modes,
16915                 .input_mux = &alc662_eeepc_capture_source,
16916                 .unsol_event = alc663_mode5_unsol_event,
16917                 .init_hook = alc663_mode5_inithook,
16918         },
16919         [ALC663_ASUS_MODE6] = {
16920                 .mixers = { alc663_two_hp_m2_mixer },
16921                 .cap_mixer = alc662_auto_capture_mixer,
16922                 .init_verbs = { alc662_init_verbs,
16923                                 alc663_two_hp_amic_m2_init_verbs },
16924                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16925                 .hp_nid = 0x03,
16926                 .dac_nids = alc662_dac_nids,
16927                 .dig_out_nid = ALC662_DIGOUT_NID,
16928                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16929                 .channel_mode = alc662_3ST_2ch_modes,
16930                 .input_mux = &alc662_eeepc_capture_source,
16931                 .unsol_event = alc663_mode6_unsol_event,
16932                 .init_hook = alc663_mode6_inithook,
16933         },
16934         [ALC272_DELL] = {
16935                 .mixers = { alc663_m51va_mixer },
16936                 .cap_mixer = alc272_auto_capture_mixer,
16937                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
16938                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
16939                 .dac_nids = alc662_dac_nids,
16940                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16941                 .adc_nids = alc272_adc_nids,
16942                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
16943                 .capsrc_nids = alc272_capsrc_nids,
16944                 .channel_mode = alc662_3ST_2ch_modes,
16945                 .input_mux = &alc663_m51va_capture_source,
16946                 .unsol_event = alc663_m51va_unsol_event,
16947                 .init_hook = alc663_m51va_inithook,
16948         },
16949         [ALC272_DELL_ZM1] = {
16950                 .mixers = { alc663_m51va_mixer },
16951                 .cap_mixer = alc662_auto_capture_mixer,
16952                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
16953                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
16954                 .dac_nids = alc662_dac_nids,
16955                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16956                 .adc_nids = alc662_adc_nids,
16957                 .num_adc_nids = ARRAY_SIZE(alc662_adc_nids),
16958                 .capsrc_nids = alc662_capsrc_nids,
16959                 .channel_mode = alc662_3ST_2ch_modes,
16960                 .input_mux = &alc663_m51va_capture_source,
16961                 .unsol_event = alc663_m51va_unsol_event,
16962                 .init_hook = alc663_m51va_inithook,
16963         },
16964         [ALC272_SAMSUNG_NC10] = {
16965                 .mixers = { alc272_nc10_mixer },
16966                 .init_verbs = { alc662_init_verbs,
16967                                 alc663_21jd_amic_init_verbs },
16968                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
16969                 .dac_nids = alc272_dac_nids,
16970                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16971                 .channel_mode = alc662_3ST_2ch_modes,
16972                 .input_mux = &alc272_nc10_capture_source,
16973                 .unsol_event = alc663_mode4_unsol_event,
16974                 .init_hook = alc663_mode4_inithook,
16975         },
16976 };
16977
16978
16979 /*
16980  * BIOS auto configuration
16981  */
16982
16983 /* add playback controls from the parsed DAC table */
16984 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
16985                                              const struct auto_pin_cfg *cfg)
16986 {
16987         char name[32];
16988         static const char *chname[4] = {
16989                 "Front", "Surround", NULL /*CLFE*/, "Side"
16990         };
16991         hda_nid_t nid;
16992         int i, err;
16993
16994         for (i = 0; i < cfg->line_outs; i++) {
16995                 if (!spec->multiout.dac_nids[i])
16996                         continue;
16997                 nid = alc880_idx_to_dac(i);
16998                 if (i == 2) {
16999                         /* Center/LFE */
17000                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
17001                                           "Center Playback Volume",
17002                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
17003                                                               HDA_OUTPUT));
17004                         if (err < 0)
17005                                 return err;
17006                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
17007                                           "LFE Playback Volume",
17008                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
17009                                                               HDA_OUTPUT));
17010                         if (err < 0)
17011                                 return err;
17012                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
17013                                           "Center Playback Switch",
17014                                           HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
17015                                                               HDA_INPUT));
17016                         if (err < 0)
17017                                 return err;
17018                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
17019                                           "LFE Playback Switch",
17020                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
17021                                                               HDA_INPUT));
17022                         if (err < 0)
17023                                 return err;
17024                 } else {
17025                         sprintf(name, "%s Playback Volume", chname[i]);
17026                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
17027                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
17028                                                               HDA_OUTPUT));
17029                         if (err < 0)
17030                                 return err;
17031                         sprintf(name, "%s Playback Switch", chname[i]);
17032                         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
17033                                 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
17034                                                     3, 0, HDA_INPUT));
17035                         if (err < 0)
17036                                 return err;
17037                 }
17038         }
17039         return 0;
17040 }
17041
17042 /* add playback controls for speaker and HP outputs */
17043 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
17044                                         const char *pfx)
17045 {
17046         hda_nid_t nid;
17047         int err;
17048         char name[32];
17049
17050         if (!pin)
17051                 return 0;
17052
17053         if (pin == 0x17) {
17054                 /* ALC663 has a mono output pin on 0x17 */
17055                 sprintf(name, "%s Playback Switch", pfx);
17056                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
17057                                   HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
17058                 return err;
17059         }
17060
17061         if (alc880_is_fixed_pin(pin)) {
17062                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
17063                 /* printk(KERN_DEBUG "DAC nid=%x\n",nid); */
17064                 /* specify the DAC as the extra output */
17065                 if (!spec->multiout.hp_nid)
17066                         spec->multiout.hp_nid = nid;
17067                 else
17068                         spec->multiout.extra_out_nid[0] = nid;
17069                 /* control HP volume/switch on the output mixer amp */
17070                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
17071                 sprintf(name, "%s Playback Volume", pfx);
17072                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
17073                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
17074                 if (err < 0)
17075                         return err;
17076                 sprintf(name, "%s Playback Switch", pfx);
17077                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
17078                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
17079                 if (err < 0)
17080                         return err;
17081         } else if (alc880_is_multi_pin(pin)) {
17082                 /* set manual connection */
17083                 /* we have only a switch on HP-out PIN */
17084                 sprintf(name, "%s Playback Switch", pfx);
17085                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
17086                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17087                 if (err < 0)
17088                         return err;
17089         }
17090         return 0;
17091 }
17092
17093 /* return the index of the src widget from the connection list of the nid.
17094  * return -1 if not found
17095  */
17096 static int alc662_input_pin_idx(struct hda_codec *codec, hda_nid_t nid,
17097                                 hda_nid_t src)
17098 {
17099         hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
17100         int i, conns;
17101
17102         conns = snd_hda_get_connections(codec, nid, conn_list,
17103                                         ARRAY_SIZE(conn_list));
17104         if (conns < 0)
17105                 return -1;
17106         for (i = 0; i < conns; i++)
17107                 if (conn_list[i] == src)
17108                         return i;
17109         return -1;
17110 }
17111
17112 static int alc662_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
17113 {
17114         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
17115         return (pincap & AC_PINCAP_IN) != 0;
17116 }
17117
17118 /* create playback/capture controls for input pins */
17119 static int alc662_auto_create_analog_input_ctls(struct hda_codec *codec,
17120                                                 const struct auto_pin_cfg *cfg)
17121 {
17122         struct alc_spec *spec = codec->spec;
17123         struct hda_input_mux *imux = &spec->private_imux[0];
17124         int i, err, idx;
17125
17126         for (i = 0; i < AUTO_PIN_LAST; i++) {
17127                 if (alc662_is_input_pin(codec, cfg->input_pins[i])) {
17128                         idx = alc662_input_pin_idx(codec, 0x0b,
17129                                                    cfg->input_pins[i]);
17130                         if (idx >= 0) {
17131                                 err = new_analog_input(spec, cfg->input_pins[i],
17132                                                        auto_pin_cfg_labels[i],
17133                                                        idx, 0x0b);
17134                                 if (err < 0)
17135                                         return err;
17136                         }
17137                         idx = alc662_input_pin_idx(codec, 0x22,
17138                                                    cfg->input_pins[i]);
17139                         if (idx >= 0) {
17140                                 imux->items[imux->num_items].label =
17141                                         auto_pin_cfg_labels[i];
17142                                 imux->items[imux->num_items].index = idx;
17143                                 imux->num_items++;
17144                         }
17145                 }
17146         }
17147         return 0;
17148 }
17149
17150 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
17151                                               hda_nid_t nid, int pin_type,
17152                                               int dac_idx)
17153 {
17154         alc_set_pin_output(codec, nid, pin_type);
17155         /* need the manual connection? */
17156         if (alc880_is_multi_pin(nid)) {
17157                 struct alc_spec *spec = codec->spec;
17158                 int idx = alc880_multi_pin_idx(nid);
17159                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
17160                                     AC_VERB_SET_CONNECT_SEL,
17161                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
17162         }
17163 }
17164
17165 static void alc662_auto_init_multi_out(struct hda_codec *codec)
17166 {
17167         struct alc_spec *spec = codec->spec;
17168         int i;
17169
17170         for (i = 0; i <= HDA_SIDE; i++) {
17171                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
17172                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
17173                 if (nid)
17174                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
17175                                                           i);
17176         }
17177 }
17178
17179 static void alc662_auto_init_hp_out(struct hda_codec *codec)
17180 {
17181         struct alc_spec *spec = codec->spec;
17182         hda_nid_t pin;
17183
17184         pin = spec->autocfg.hp_pins[0];
17185         if (pin) /* connect to front */
17186                 /* use dac 0 */
17187                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
17188         pin = spec->autocfg.speaker_pins[0];
17189         if (pin)
17190                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
17191 }
17192
17193 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
17194
17195 static void alc662_auto_init_analog_input(struct hda_codec *codec)
17196 {
17197         struct alc_spec *spec = codec->spec;
17198         int i;
17199
17200         for (i = 0; i < AUTO_PIN_LAST; i++) {
17201                 hda_nid_t nid = spec->autocfg.input_pins[i];
17202                 if (alc662_is_input_pin(codec, nid)) {
17203                         alc_set_input_pin(codec, nid, i);
17204                         if (nid != ALC662_PIN_CD_NID &&
17205                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17206                                 snd_hda_codec_write(codec, nid, 0,
17207                                                     AC_VERB_SET_AMP_GAIN_MUTE,
17208                                                     AMP_OUT_MUTE);
17209                 }
17210         }
17211 }
17212
17213 #define alc662_auto_init_input_src      alc882_auto_init_input_src
17214
17215 static int alc662_parse_auto_config(struct hda_codec *codec)
17216 {
17217         struct alc_spec *spec = codec->spec;
17218         int err;
17219         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
17220
17221         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17222                                            alc662_ignore);
17223         if (err < 0)
17224                 return err;
17225         if (!spec->autocfg.line_outs)
17226                 return 0; /* can't find valid BIOS pin config */
17227
17228         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17229         if (err < 0)
17230                 return err;
17231         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
17232         if (err < 0)
17233                 return err;
17234         err = alc662_auto_create_extra_out(spec,
17235                                            spec->autocfg.speaker_pins[0],
17236                                            "Speaker");
17237         if (err < 0)
17238                 return err;
17239         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
17240                                            "Headphone");
17241         if (err < 0)
17242                 return err;
17243         err = alc662_auto_create_analog_input_ctls(codec, &spec->autocfg);
17244         if (err < 0)
17245                 return err;
17246
17247         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17248
17249         if (spec->autocfg.dig_outs)
17250                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
17251
17252         if (spec->kctls.list)
17253                 add_mixer(spec, spec->kctls.list);
17254
17255         spec->num_mux_defs = 1;
17256         spec->input_mux = &spec->private_imux[0];
17257
17258         add_verb(spec, alc662_auto_init_verbs);
17259         if (codec->vendor_id == 0x10ec0663)
17260                 add_verb(spec, alc663_auto_init_verbs);
17261
17262         err = alc_auto_add_mic_boost(codec);
17263         if (err < 0)
17264                 return err;
17265
17266         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
17267
17268         return 1;
17269 }
17270
17271 /* additional initialization for auto-configuration model */
17272 static void alc662_auto_init(struct hda_codec *codec)
17273 {
17274         struct alc_spec *spec = codec->spec;
17275         alc662_auto_init_multi_out(codec);
17276         alc662_auto_init_hp_out(codec);
17277         alc662_auto_init_analog_input(codec);
17278         alc662_auto_init_input_src(codec);
17279         if (spec->unsol_event)
17280                 alc_inithook(codec);
17281 }
17282
17283 static int patch_alc662(struct hda_codec *codec)
17284 {
17285         struct alc_spec *spec;
17286         int err, board_config;
17287
17288         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17289         if (!spec)
17290                 return -ENOMEM;
17291
17292         codec->spec = spec;
17293
17294         alc_fix_pll_init(codec, 0x20, 0x04, 15);
17295
17296         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
17297                                                   alc662_models,
17298                                                   alc662_cfg_tbl);
17299         if (board_config < 0) {
17300                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
17301                        "trying auto-probe from BIOS...\n", codec->chip_name);
17302                 board_config = ALC662_AUTO;
17303         }
17304
17305         if (board_config == ALC662_AUTO) {
17306                 /* automatic parse from the BIOS config */
17307                 err = alc662_parse_auto_config(codec);
17308                 if (err < 0) {
17309                         alc_free(codec);
17310                         return err;
17311                 } else if (!err) {
17312                         printk(KERN_INFO
17313                                "hda_codec: Cannot set up configuration "
17314                                "from BIOS.  Using base mode...\n");
17315                         board_config = ALC662_3ST_2ch_DIG;
17316                 }
17317         }
17318
17319         err = snd_hda_attach_beep_device(codec, 0x1);
17320         if (err < 0) {
17321                 alc_free(codec);
17322                 return err;
17323         }
17324
17325         if (board_config != ALC662_AUTO)
17326                 setup_preset(spec, &alc662_presets[board_config]);
17327
17328         spec->stream_analog_playback = &alc662_pcm_analog_playback;
17329         spec->stream_analog_capture = &alc662_pcm_analog_capture;
17330
17331         spec->stream_digital_playback = &alc662_pcm_digital_playback;
17332         spec->stream_digital_capture = &alc662_pcm_digital_capture;
17333
17334         spec->adc_nids = alc662_adc_nids;
17335         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
17336         spec->capsrc_nids = alc662_capsrc_nids;
17337
17338         if (!spec->cap_mixer)
17339                 set_capture_mixer(spec);
17340         if (codec->vendor_id == 0x10ec0662)
17341                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17342         else
17343                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
17344
17345         spec->vmaster_nid = 0x02;
17346
17347         codec->patch_ops = alc_patch_ops;
17348         if (board_config == ALC662_AUTO)
17349                 spec->init_hook = alc662_auto_init;
17350 #ifdef CONFIG_SND_HDA_POWER_SAVE
17351         if (!spec->loopback.amplist)
17352                 spec->loopback.amplist = alc662_loopbacks;
17353 #endif
17354         codec->proc_widget_hook = print_realtek_coef;
17355
17356         return 0;
17357 }
17358
17359 /*
17360  * patch entries
17361  */
17362 static struct hda_codec_preset snd_hda_preset_realtek[] = {
17363         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
17364         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
17365         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
17366         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
17367         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
17368         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
17369         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
17370           .patch = patch_alc861 },
17371         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
17372         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
17373         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
17374         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
17375           .patch = patch_alc882 },
17376         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
17377           .patch = patch_alc662 },
17378         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
17379         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
17380         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
17381         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
17382         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
17383           .patch = patch_alc882 },
17384         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
17385           .patch = patch_alc882 },
17386         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
17387         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
17388         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
17389           .patch = patch_alc882 },
17390         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
17391         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
17392         {} /* terminator */
17393 };
17394
17395 MODULE_ALIAS("snd-hda-codec-id:10ec*");
17396
17397 MODULE_LICENSE("GPL");
17398 MODULE_DESCRIPTION("Realtek HD-audio codec");
17399
17400 static struct hda_codec_preset_list realtek_list = {
17401         .preset = snd_hda_preset_realtek,
17402         .owner = THIS_MODULE,
17403 };
17404
17405 static int __init patch_realtek_init(void)
17406 {
17407         return snd_hda_add_codec_preset(&realtek_list);
17408 }
17409
17410 static void __exit patch_realtek_exit(void)
17411 {
17412         snd_hda_delete_codec_preset(&realtek_list);
17413 }
17414
17415 module_init(patch_realtek_init)
17416 module_exit(patch_realtek_exit)