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 <sound/jack.h>
  32 #include "hda_codec.h"
  33 #include "hda_local.h"
  34 #include "hda_beep.h"
  35
  36 #define ALC880_FRONT_EVENT              0x01
  37 #define ALC880_DCVOL_EVENT              0x02
  38 #define ALC880_HP_EVENT                 0x04
  39 #define ALC880_MIC_EVENT                0x08
  40
  41 /* ALC880 board config type */
  42 enum {
  43         ALC880_3ST,
  44         ALC880_3ST_DIG,
  45         ALC880_5ST,
  46         ALC880_5ST_DIG,
  47         ALC880_W810,
  48         ALC880_Z71V,
  49         ALC880_6ST,
  50         ALC880_6ST_DIG,
  51         ALC880_F1734,
  52         ALC880_ASUS,
  53         ALC880_ASUS_DIG,
  54         ALC880_ASUS_W1V,
  55         ALC880_ASUS_DIG2,
  56         ALC880_FUJITSU,
  57         ALC880_UNIWILL_DIG,
  58         ALC880_UNIWILL,
  59         ALC880_UNIWILL_P53,
  60         ALC880_CLEVO,
  61         ALC880_TCL_S700,
  62         ALC880_LG,
  63         ALC880_LG_LW,
  64         ALC880_MEDION_RIM,
  65 #ifdef CONFIG_SND_DEBUG
  66         ALC880_TEST,
  67 #endif
  68         ALC880_AUTO,
  69         ALC880_MODEL_LAST /* last tag */
  70 };
  71
  72 /* ALC260 models */
  73 enum {
  74         ALC260_BASIC,
  75         ALC260_HP,
  76         ALC260_HP_DC7600,
  77         ALC260_HP_3013,
  78         ALC260_FUJITSU_S702X,
  79         ALC260_ACER,
  80         ALC260_WILL,
  81         ALC260_REPLACER_672V,
  82         ALC260_FAVORIT100,
  83 #ifdef CONFIG_SND_DEBUG
  84         ALC260_TEST,
  85 #endif
  86         ALC260_AUTO,
  87         ALC260_MODEL_LAST /* last tag */
  88 };
  89
  90 /* ALC262 models */
  91 enum {
  92         ALC262_BASIC,
  93         ALC262_HIPPO,
  94         ALC262_HIPPO_1,
  95         ALC262_FUJITSU,
  96         ALC262_HP_BPC,
  97         ALC262_HP_BPC_D7000_WL,
  98         ALC262_HP_BPC_D7000_WF,
  99         ALC262_HP_TC_T5735,
 100         ALC262_HP_RP5700,
 101         ALC262_BENQ_ED8,
 102         ALC262_SONY_ASSAMD,
 103         ALC262_BENQ_T31,
 104         ALC262_ULTRA,
 105         ALC262_LENOVO_3000,
 106         ALC262_NEC,
 107         ALC262_TOSHIBA_S06,
 108         ALC262_TOSHIBA_RX1,
 109         ALC262_TYAN,
 110         ALC262_AUTO,
 111         ALC262_MODEL_LAST /* last tag */
 112 };
 113
 114 /* ALC268 models */
 115 enum {
 116         ALC267_QUANTA_IL1,
 117         ALC268_3ST,
 118         ALC268_TOSHIBA,
 119         ALC268_ACER,
 120         ALC268_ACER_DMIC,
 121         ALC268_ACER_ASPIRE_ONE,
 122         ALC268_DELL,
 123         ALC268_ZEPTO,
 124 #ifdef CONFIG_SND_DEBUG
 125         ALC268_TEST,
 126 #endif
 127         ALC268_AUTO,
 128         ALC268_MODEL_LAST /* last tag */
 129 };
 130
 131 /* ALC269 models */
 132 enum {
 133         ALC269_BASIC,
 134         ALC269_QUANTA_FL1,
 135         ALC269_AMIC,
 136         ALC269_DMIC,
 137         ALC269VB_AMIC,
 138         ALC269VB_DMIC,
 139         ALC269_FUJITSU,
 140         ALC269_LIFEBOOK,
 141         ALC271_ACER,
 142         ALC269_AUTO,
 143         ALC269_MODEL_LAST /* last tag */
 144 };
 145
 146 /* ALC861 models */
 147 enum {
 148         ALC861_3ST,
 149         ALC660_3ST,
 150         ALC861_3ST_DIG,
 151         ALC861_6ST_DIG,
 152         ALC861_UNIWILL_M31,
 153         ALC861_TOSHIBA,
 154         ALC861_ASUS,
 155         ALC861_ASUS_LAPTOP,
 156         ALC861_AUTO,
 157         ALC861_MODEL_LAST,
 158 };
 159
 160 /* ALC861-VD models */
 161 enum {
 162         ALC660VD_3ST,
 163         ALC660VD_3ST_DIG,
 164         ALC660VD_ASUS_V1S,
 165         ALC861VD_3ST,
 166         ALC861VD_3ST_DIG,
 167         ALC861VD_6ST_DIG,
 168         ALC861VD_LENOVO,
 169         ALC861VD_DALLAS,
 170         ALC861VD_HP,
 171         ALC861VD_AUTO,
 172         ALC861VD_MODEL_LAST,
 173 };
 174
 175 /* ALC662 models */
 176 enum {
 177         ALC662_3ST_2ch_DIG,
 178         ALC662_3ST_6ch_DIG,
 179         ALC662_3ST_6ch,
 180         ALC662_5ST_DIG,
 181         ALC662_LENOVO_101E,
 182         ALC662_ASUS_EEEPC_P701,
 183         ALC662_ASUS_EEEPC_EP20,
 184         ALC663_ASUS_M51VA,
 185         ALC663_ASUS_G71V,
 186         ALC663_ASUS_H13,
 187         ALC663_ASUS_G50V,
 188         ALC662_ECS,
 189         ALC663_ASUS_MODE1,
 190         ALC662_ASUS_MODE2,
 191         ALC663_ASUS_MODE3,
 192         ALC663_ASUS_MODE4,
 193         ALC663_ASUS_MODE5,
 194         ALC663_ASUS_MODE6,
 195         ALC663_ASUS_MODE7,
 196         ALC663_ASUS_MODE8,
 197         ALC272_DELL,
 198         ALC272_DELL_ZM1,
 199         ALC272_SAMSUNG_NC10,
 200         ALC662_AUTO,
 201         ALC662_MODEL_LAST,
 202 };
 203
 204 /* ALC882 models */
 205 enum {
 206         ALC882_3ST_DIG,
 207         ALC882_6ST_DIG,
 208         ALC882_ARIMA,
 209         ALC882_W2JC,
 210         ALC882_TARGA,
 211         ALC882_ASUS_A7J,
 212         ALC882_ASUS_A7M,
 213         ALC885_MACPRO,
 214         ALC885_MBA21,
 215         ALC885_MBP3,
 216         ALC885_MB5,
 217         ALC885_MACMINI3,
 218         ALC885_IMAC24,
 219         ALC885_IMAC91,
 220         ALC883_3ST_2ch_DIG,
 221         ALC883_3ST_6ch_DIG,
 222         ALC883_3ST_6ch,
 223         ALC883_6ST_DIG,
 224         ALC883_TARGA_DIG,
 225         ALC883_TARGA_2ch_DIG,
 226         ALC883_TARGA_8ch_DIG,
 227         ALC883_ACER,
 228         ALC883_ACER_ASPIRE,
 229         ALC888_ACER_ASPIRE_4930G,
 230         ALC888_ACER_ASPIRE_6530G,
 231         ALC888_ACER_ASPIRE_8930G,
 232         ALC888_ACER_ASPIRE_7730G,
 233         ALC883_MEDION,
 234         ALC883_MEDION_WIM2160,
 235         ALC883_LAPTOP_EAPD,
 236         ALC883_LENOVO_101E_2ch,
 237         ALC883_LENOVO_NB0763,
 238         ALC888_LENOVO_MS7195_DIG,
 239         ALC888_LENOVO_SKY,
 240         ALC883_HAIER_W66,
 241         ALC888_3ST_HP,
 242         ALC888_6ST_DELL,
 243         ALC883_MITAC,
 244         ALC883_CLEVO_M540R,
 245         ALC883_CLEVO_M720,
 246         ALC883_FUJITSU_PI2515,
 247         ALC888_FUJITSU_XA3530,
 248         ALC883_3ST_6ch_INTEL,
 249         ALC889A_INTEL,
 250         ALC889_INTEL,
 251         ALC888_ASUS_M90V,
 252         ALC888_ASUS_EEE1601,
 253         ALC889A_MB31,
 254         ALC1200_ASUS_P5Q,
 255         ALC883_SONY_VAIO_TT,
 256         ALC882_AUTO,
 257         ALC882_MODEL_LAST,
 258 };
 259
 260 /* ALC680 models */
 261 enum {
 262         ALC680_BASE,
 263         ALC680_AUTO,
 264         ALC680_MODEL_LAST,
 265 };
 266
 267 /* for GPIO Poll */
 268 #define GPIO_MASK       0x03
 269
 270 /* extra amp-initialization sequence types */
 271 enum {
 272         ALC_INIT_NONE,
 273         ALC_INIT_DEFAULT,
 274         ALC_INIT_GPIO1,
 275         ALC_INIT_GPIO2,
 276         ALC_INIT_GPIO3,
 277 };
 278
 279 struct alc_mic_route {
 280         hda_nid_t pin;
 281         unsigned char mux_idx;
 282         unsigned char amix_idx;
 283 };
 284
 285 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 286
 287 struct alc_customize_define {
 288         unsigned int  sku_cfg;
 289         unsigned char port_connectivity;
 290         unsigned char check_sum;
 291         unsigned char customization;
 292         unsigned char external_amp;
 293         unsigned int  enable_pcbeep:1;
 294         unsigned int  platform_type:1;
 295         unsigned int  swap:1;
 296         unsigned int  override:1;
 297         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
 298 };
 299
 300 struct alc_fixup;
 301
 302 struct alc_multi_io {
 303         hda_nid_t pin;          /* multi-io widget pin NID */
 304         hda_nid_t dac;          /* DAC to be connected */
 305         unsigned int ctl_in;    /* cached input-pin control value */
 306 };
 307
 308 enum {
 309         ALC_AUTOMUTE_PIN,       /* change the pin control */
 310         ALC_AUTOMUTE_AMP,       /* mute/unmute the pin AMP */
 311         ALC_AUTOMUTE_MIXER,     /* mute/unmute mixer widget AMP */
 312 };
 313
 314 struct alc_spec {
 315         /* codec parameterization */
 316         const struct snd_kcontrol_new *mixers[5];       /* mixer arrays */
 317         unsigned int num_mixers;
 318         const struct snd_kcontrol_new *cap_mixer;       /* capture mixer */
 319         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 320
 321         const struct hda_verb *init_verbs[10];  /* initialization verbs
 322                                                  * don't forget NULL
 323                                                  * termination!
 324                                                  */
 325         unsigned int num_init_verbs;
 326
 327         char stream_name_analog[32];    /* analog PCM stream */
 328         const struct hda_pcm_stream *stream_analog_playback;
 329         const struct hda_pcm_stream *stream_analog_capture;
 330         const struct hda_pcm_stream *stream_analog_alt_playback;
 331         const struct hda_pcm_stream *stream_analog_alt_capture;
 332
 333         char stream_name_digital[32];   /* digital PCM stream */
 334         const struct hda_pcm_stream *stream_digital_playback;
 335         const struct hda_pcm_stream *stream_digital_capture;
 336
 337         /* playback */
 338         struct hda_multi_out multiout;  /* playback set-up
 339                                          * max_channels, dacs must be set
 340                                          * dig_out_nid and hp_nid are optional
 341                                          */
 342         hda_nid_t alt_dac_nid;
 343         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 344         int dig_out_type;
 345
 346         /* capture */
 347         unsigned int num_adc_nids;
 348         const hda_nid_t *adc_nids;
 349         const hda_nid_t *capsrc_nids;
 350         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 351
 352         /* capture setup for dynamic dual-adc switch */
 353         unsigned int cur_adc_idx;
 354         hda_nid_t cur_adc;
 355         unsigned int cur_adc_stream_tag;
 356         unsigned int cur_adc_format;
 357
 358         /* capture source */
 359         unsigned int num_mux_defs;
 360         const struct hda_input_mux *input_mux;
 361         unsigned int cur_mux[3];
 362         struct alc_mic_route ext_mic;
 363         struct alc_mic_route dock_mic;
 364         struct alc_mic_route int_mic;
 365
 366         /* channel model */
 367         const struct hda_channel_mode *channel_mode;
 368         int num_channel_mode;
 369         int need_dac_fix;
 370         int const_channel_count;
 371         int ext_channel_count;
 372
 373         /* PCM information */
 374         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 375
 376         /* dynamic controls, init_verbs and input_mux */
 377         struct auto_pin_cfg autocfg;
 378         struct alc_customize_define cdefine;
 379         struct snd_array kctls;
 380         struct hda_input_mux private_imux[3];
 381         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 382         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 383         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 384
 385         /* hooks */
 386         void (*init_hook)(struct hda_codec *codec);
 387         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 388 #ifdef CONFIG_SND_HDA_POWER_SAVE
 389         void (*power_hook)(struct hda_codec *codec);
 390 #endif
 391         void (*shutup)(struct hda_codec *codec);
 392
 393         /* for pin sensing */
 394         unsigned int jack_present: 1;
 395         unsigned int line_jack_present:1;
 396         unsigned int master_mute:1;
 397         unsigned int auto_mic:1;
 398         unsigned int automute:1;        /* HP automute enabled */
 399         unsigned int detect_line:1;     /* Line-out detection enabled */
 400         unsigned int automute_lines:1;  /* automute line-out as well */
 401         unsigned int automute_hp_lo:1;  /* both HP and LO available */
 402
 403         /* other flags */
 404         unsigned int no_analog :1; /* digital I/O only */
 405         unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */
 406         unsigned int single_input_src:1;
 407
 408         /* auto-mute control */
 409         int automute_mode;
 410         hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS];
 411
 412         int init_amp;
 413         int codec_variant;      /* flag for other variants */
 414
 415         /* for virtual master */
 416         hda_nid_t vmaster_nid;
 417 #ifdef CONFIG_SND_HDA_POWER_SAVE
 418         struct hda_loopback_check loopback;
 419 #endif
 420
 421         /* for PLL fix */
 422         hda_nid_t pll_nid;
 423         unsigned int pll_coef_idx, pll_coef_bit;
 424
 425         /* fix-up list */
 426         int fixup_id;
 427         const struct alc_fixup *fixup_list;
 428         const char *fixup_name;
 429
 430         /* multi-io */
 431         int multi_ios;
 432         struct alc_multi_io multi_io[4];
 433 };
 434
 435 /*
 436  * configuration template - to be copied to the spec instance
 437  */
 438 struct alc_config_preset {
 439         const struct snd_kcontrol_new *mixers[5]; /* should be identical size
 440                                              * with spec
 441                                              */
 442         const struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 443         const struct hda_verb *init_verbs[5];
 444         unsigned int num_dacs;
 445         const hda_nid_t *dac_nids;
 446         hda_nid_t dig_out_nid;          /* optional */
 447         hda_nid_t hp_nid;               /* optional */
 448         const hda_nid_t *slave_dig_outs;
 449         unsigned int num_adc_nids;
 450         const hda_nid_t *adc_nids;
 451         const hda_nid_t *capsrc_nids;
 452         hda_nid_t dig_in_nid;
 453         unsigned int num_channel_mode;
 454         const struct hda_channel_mode *channel_mode;
 455         int need_dac_fix;
 456         int const_channel_count;
 457         unsigned int num_mux_defs;
 458         const struct hda_input_mux *input_mux;
 459         void (*unsol_event)(struct hda_codec *, unsigned int);
 460         void (*setup)(struct hda_codec *);
 461         void (*init_hook)(struct hda_codec *);
 462 #ifdef CONFIG_SND_HDA_POWER_SAVE
 463         const struct hda_amp_list *loopbacks;
 464         void (*power_hook)(struct hda_codec *codec);
 465 #endif
 466 };
 467
 468
 469 /*
 470  * input MUX handling
 471  */
 472 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 473                              struct snd_ctl_elem_info *uinfo)
 474 {
 475         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 476         struct alc_spec *spec = codec->spec;
 477         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 478         if (mux_idx >= spec->num_mux_defs)
 479                 mux_idx = 0;
 480         if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
 481                 mux_idx = 0;
 482         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 483 }
 484
 485 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 486                             struct snd_ctl_elem_value *ucontrol)
 487 {
 488         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 489         struct alc_spec *spec = codec->spec;
 490         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 491
 492         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 493         return 0;
 494 }
 495
 496 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 497                             struct snd_ctl_elem_value *ucontrol)
 498 {
 499         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 500         struct alc_spec *spec = codec->spec;
 501         const struct hda_input_mux *imux;
 502         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 503         unsigned int mux_idx;
 504         hda_nid_t nid = spec->capsrc_nids ?
 505                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 506         unsigned int type;
 507
 508         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 509         imux = &spec->input_mux[mux_idx];
 510         if (!imux->num_items && mux_idx > 0)
 511                 imux = &spec->input_mux[0];
 512
 513         type = get_wcaps_type(get_wcaps(codec, nid));
 514         if (type == AC_WID_AUD_MIX) {
 515                 /* Matrix-mixer style (e.g. ALC882) */
 516                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 517                 unsigned int i, idx;
 518
 519                 idx = ucontrol->value.enumerated.item[0];
 520                 if (idx >= imux->num_items)
 521                         idx = imux->num_items - 1;
 522                 if (*cur_val == idx)
 523                         return 0;
 524                 for (i = 0; i < imux->num_items; i++) {
 525                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 526                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 527                                                  imux->items[i].index,
 528                                                  HDA_AMP_MUTE, v);
 529                 }
 530                 *cur_val = idx;
 531                 return 1;
 532         } else {
 533                 /* MUX style (e.g. ALC880) */
 534                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 535                                              &spec->cur_mux[adc_idx]);
 536         }
 537 }
 538
 539 /*
 540  * channel mode setting
 541  */
 542 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 543                             struct snd_ctl_elem_info *uinfo)
 544 {
 545         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 546         struct alc_spec *spec = codec->spec;
 547         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 548                                     spec->num_channel_mode);
 549 }
 550
 551 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 552                            struct snd_ctl_elem_value *ucontrol)
 553 {
 554         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 555         struct alc_spec *spec = codec->spec;
 556         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 557                                    spec->num_channel_mode,
 558                                    spec->ext_channel_count);
 559 }
 560
 561 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 562                            struct snd_ctl_elem_value *ucontrol)
 563 {
 564         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 565         struct alc_spec *spec = codec->spec;
 566         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 567                                       spec->num_channel_mode,
 568                                       &spec->ext_channel_count);
 569         if (err >= 0 && !spec->const_channel_count) {
 570                 spec->multiout.max_channels = spec->ext_channel_count;
 571                 if (spec->need_dac_fix)
 572                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 573         }
 574         return err;
 575 }
 576
 577 /*
 578  * Control the mode of pin widget settings via the mixer.  "pc" is used
 579  * instead of "%" to avoid consequences of accidentally treating the % as
 580  * being part of a format specifier.  Maximum allowed length of a value is
 581  * 63 characters plus NULL terminator.
 582  *
 583  * Note: some retasking pin complexes seem to ignore requests for input
 584  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 585  * are requested.  Therefore order this list so that this behaviour will not
 586  * cause problems when mixer clients move through the enum sequentially.
 587  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 588  * March 2006.
 589  */
 590 static const char * const alc_pin_mode_names[] = {
 591         "Mic 50pc bias", "Mic 80pc bias",
 592         "Line in", "Line out", "Headphone out",
 593 };
 594 static const unsigned char alc_pin_mode_values[] = {
 595         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 596 };
 597 /* The control can present all 5 options, or it can limit the options based
 598  * in the pin being assumed to be exclusively an input or an output pin.  In
 599  * addition, "input" pins may or may not process the mic bias option
 600  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 601  * accept requests for bias as of chip versions up to March 2006) and/or
 602  * wiring in the computer.
 603  */
 604 #define ALC_PIN_DIR_IN              0x00
 605 #define ALC_PIN_DIR_OUT             0x01
 606 #define ALC_PIN_DIR_INOUT           0x02
 607 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 608 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 609
 610 /* Info about the pin modes supported by the different pin direction modes.
 611  * For each direction the minimum and maximum values are given.
 612  */
 613 static const signed char alc_pin_mode_dir_info[5][2] = {
 614         { 0, 2 },    /* ALC_PIN_DIR_IN */
 615         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 616         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 617         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 618         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 619 };
 620 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 621 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 622 #define alc_pin_mode_n_items(_dir) \
 623         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 624
 625 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 626                              struct snd_ctl_elem_info *uinfo)
 627 {
 628         unsigned int item_num = uinfo->value.enumerated.item;
 629         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 630
 631         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 632         uinfo->count = 1;
 633         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 634
 635         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 636                 item_num = alc_pin_mode_min(dir);
 637         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 638         return 0;
 639 }
 640
 641 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 642                             struct snd_ctl_elem_value *ucontrol)
 643 {
 644         unsigned int i;
 645         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 646         hda_nid_t nid = kcontrol->private_value & 0xffff;
 647         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 648         long *valp = ucontrol->value.integer.value;
 649         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 650                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 651                                                  0x00);
 652
 653         /* Find enumerated value for current pinctl setting */
 654         i = alc_pin_mode_min(dir);
 655         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 656                 i++;
 657         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 658         return 0;
 659 }
 660
 661 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 662                             struct snd_ctl_elem_value *ucontrol)
 663 {
 664         signed int change;
 665         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 666         hda_nid_t nid = kcontrol->private_value & 0xffff;
 667         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 668         long val = *ucontrol->value.integer.value;
 669         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 670                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 671                                                  0x00);
 672
 673         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 674                 val = alc_pin_mode_min(dir);
 675
 676         change = pinctl != alc_pin_mode_values[val];
 677         if (change) {
 678                 /* Set pin mode to that requested */
 679                 snd_hda_codec_write_cache(codec, nid, 0,
 680                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 681                                           alc_pin_mode_values[val]);
 682
 683                 /* Also enable the retasking pin's input/output as required
 684                  * for the requested pin mode.  Enum values of 2 or less are
 685                  * input modes.
 686                  *
 687                  * Dynamically switching the input/output buffers probably
 688                  * reduces noise slightly (particularly on input) so we'll
 689                  * do it.  However, having both input and output buffers
 690                  * enabled simultaneously doesn't seem to be problematic if
 691                  * this turns out to be necessary in the future.
 692                  */
 693                 if (val <= 2) {
 694                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 695                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 696                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 697                                                  HDA_AMP_MUTE, 0);
 698                 } else {
 699                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 700                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 701                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 702                                                  HDA_AMP_MUTE, 0);
 703                 }
 704         }
 705         return change;
 706 }
 707
 708 #define ALC_PIN_MODE(xname, nid, dir) \
 709         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 710           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 711           .info = alc_pin_mode_info, \
 712           .get = alc_pin_mode_get, \
 713           .put = alc_pin_mode_put, \
 714           .private_value = nid | (dir<<16) }
 715
 716 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 717  * together using a mask with more than one bit set.  This control is
 718  * currently used only by the ALC260 test model.  At this stage they are not
 719  * needed for any "production" models.
 720  */
 721 #ifdef CONFIG_SND_DEBUG
 722 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 723
 724 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 725                              struct snd_ctl_elem_value *ucontrol)
 726 {
 727         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 728         hda_nid_t nid = kcontrol->private_value & 0xffff;
 729         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 730         long *valp = ucontrol->value.integer.value;
 731         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 732                                               AC_VERB_GET_GPIO_DATA, 0x00);
 733
 734         *valp = (val & mask) != 0;
 735         return 0;
 736 }
 737 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 738                              struct snd_ctl_elem_value *ucontrol)
 739 {
 740         signed int change;
 741         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 742         hda_nid_t nid = kcontrol->private_value & 0xffff;
 743         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 744         long val = *ucontrol->value.integer.value;
 745         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 746                                                     AC_VERB_GET_GPIO_DATA,
 747                                                     0x00);
 748
 749         /* Set/unset the masked GPIO bit(s) as needed */
 750         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 751         if (val == 0)
 752                 gpio_data &= ~mask;
 753         else
 754                 gpio_data |= mask;
 755         snd_hda_codec_write_cache(codec, nid, 0,
 756                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 757
 758         return change;
 759 }
 760 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 761         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 762           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 763           .info = alc_gpio_data_info, \
 764           .get = alc_gpio_data_get, \
 765           .put = alc_gpio_data_put, \
 766           .private_value = nid | (mask<<16) }
 767 #endif   /* CONFIG_SND_DEBUG */
 768
 769 /* A switch control to allow the enabling of the digital IO pins on the
 770  * ALC260.  This is incredibly simplistic; the intention of this control is
 771  * to provide something in the test model allowing digital outputs to be
 772  * identified if present.  If models are found which can utilise these
 773  * outputs a more complete mixer control can be devised for those models if
 774  * necessary.
 775  */
 776 #ifdef CONFIG_SND_DEBUG
 777 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 778
 779 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 780                               struct snd_ctl_elem_value *ucontrol)
 781 {
 782         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 783         hda_nid_t nid = kcontrol->private_value & 0xffff;
 784         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 785         long *valp = ucontrol->value.integer.value;
 786         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 787                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 788
 789         *valp = (val & mask) != 0;
 790         return 0;
 791 }
 792 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 793                               struct snd_ctl_elem_value *ucontrol)
 794 {
 795         signed int change;
 796         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 797         hda_nid_t nid = kcontrol->private_value & 0xffff;
 798         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 799         long val = *ucontrol->value.integer.value;
 800         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 801                                                     AC_VERB_GET_DIGI_CONVERT_1,
 802                                                     0x00);
 803
 804         /* Set/unset the masked control bit(s) as needed */
 805         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 806         if (val==0)
 807                 ctrl_data &= ~mask;
 808         else
 809                 ctrl_data |= mask;
 810         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 811                                   ctrl_data);
 812
 813         return change;
 814 }
 815 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 816         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 817           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 818           .info = alc_spdif_ctrl_info, \
 819           .get = alc_spdif_ctrl_get, \
 820           .put = alc_spdif_ctrl_put, \
 821           .private_value = nid | (mask<<16) }
 822 #endif   /* CONFIG_SND_DEBUG */
 823
 824 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 825  * Again, this is only used in the ALC26x test models to help identify when
 826  * the EAPD line must be asserted for features to work.
 827  */
 828 #ifdef CONFIG_SND_DEBUG
 829 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 830
 831 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 832                               struct snd_ctl_elem_value *ucontrol)
 833 {
 834         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 835         hda_nid_t nid = kcontrol->private_value & 0xffff;
 836         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 837         long *valp = ucontrol->value.integer.value;
 838         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 839                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 840
 841         *valp = (val & mask) != 0;
 842         return 0;
 843 }
 844
 845 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 846                               struct snd_ctl_elem_value *ucontrol)
 847 {
 848         int change;
 849         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 850         hda_nid_t nid = kcontrol->private_value & 0xffff;
 851         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 852         long val = *ucontrol->value.integer.value;
 853         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 854                                                     AC_VERB_GET_EAPD_BTLENABLE,
 855                                                     0x00);
 856
 857         /* Set/unset the masked control bit(s) as needed */
 858         change = (!val ? 0 : mask) != (ctrl_data & mask);
 859         if (!val)
 860                 ctrl_data &= ~mask;
 861         else
 862                 ctrl_data |= mask;
 863         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 864                                   ctrl_data);
 865
 866         return change;
 867 }
 868
 869 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 870         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 871           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 872           .info = alc_eapd_ctrl_info, \
 873           .get = alc_eapd_ctrl_get, \
 874           .put = alc_eapd_ctrl_put, \
 875           .private_value = nid | (mask<<16) }
 876 #endif   /* CONFIG_SND_DEBUG */
 877
 878 /*
 879  * set up the input pin config (depending on the given auto-pin type)
 880  */
 881 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 882                               int auto_pin_type)
 883 {
 884         unsigned int val = PIN_IN;
 885
 886         if (auto_pin_type == AUTO_PIN_MIC) {
 887                 unsigned int pincap;
 888                 unsigned int oldval;
 889                 oldval = snd_hda_codec_read(codec, nid, 0,
 890                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 891                 pincap = snd_hda_query_pin_caps(codec, nid);
 892                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 893                 /* if the default pin setup is vref50, we give it priority */
 894                 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
 895                         val = PIN_VREF80;
 896                 else if (pincap & AC_PINCAP_VREF_50)
 897                         val = PIN_VREF50;
 898                 else if (pincap & AC_PINCAP_VREF_100)
 899                         val = PIN_VREF100;
 900                 else if (pincap & AC_PINCAP_VREF_GRD)
 901                         val = PIN_VREFGRD;
 902         }
 903         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 904 }
 905
 906 static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec)
 907 {
 908         struct alc_spec *spec = codec->spec;
 909         struct auto_pin_cfg *cfg = &spec->autocfg;
 910
 911         if (!cfg->line_outs) {
 912                 while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
 913                        cfg->line_out_pins[cfg->line_outs])
 914                         cfg->line_outs++;
 915         }
 916         if (!cfg->speaker_outs) {
 917                 while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
 918                        cfg->speaker_pins[cfg->speaker_outs])
 919                         cfg->speaker_outs++;
 920         }
 921         if (!cfg->hp_outs) {
 922                 while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
 923                        cfg->hp_pins[cfg->hp_outs])
 924                         cfg->hp_outs++;
 925         }
 926 }
 927
 928 /*
 929  */
 930 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
 931 {
 932         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 933                 return;
 934         spec->mixers[spec->num_mixers++] = mix;
 935 }
 936
 937 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 938 {
 939         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 940                 return;
 941         spec->init_verbs[spec->num_init_verbs++] = verb;
 942 }
 943
 944 /*
 945  * set up from the preset table
 946  */
 947 static void setup_preset(struct hda_codec *codec,
 948                          const struct alc_config_preset *preset)
 949 {
 950         struct alc_spec *spec = codec->spec;
 951         int i;
 952
 953         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 954                 add_mixer(spec, preset->mixers[i]);
 955         spec->cap_mixer = preset->cap_mixer;
 956         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 957              i++)
 958                 add_verb(spec, preset->init_verbs[i]);
 959
 960         spec->channel_mode = preset->channel_mode;
 961         spec->num_channel_mode = preset->num_channel_mode;
 962         spec->need_dac_fix = preset->need_dac_fix;
 963         spec->const_channel_count = preset->const_channel_count;
 964
 965         if (preset->const_channel_count)
 966                 spec->multiout.max_channels = preset->const_channel_count;
 967         else
 968                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 969         spec->ext_channel_count = spec->channel_mode[0].channels;
 970
 971         spec->multiout.num_dacs = preset->num_dacs;
 972         spec->multiout.dac_nids = preset->dac_nids;
 973         spec->multiout.dig_out_nid = preset->dig_out_nid;
 974         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 975         spec->multiout.hp_nid = preset->hp_nid;
 976
 977         spec->num_mux_defs = preset->num_mux_defs;
 978         if (!spec->num_mux_defs)
 979                 spec->num_mux_defs = 1;
 980         spec->input_mux = preset->input_mux;
 981
 982         spec->num_adc_nids = preset->num_adc_nids;
 983         spec->adc_nids = preset->adc_nids;
 984         spec->capsrc_nids = preset->capsrc_nids;
 985         spec->dig_in_nid = preset->dig_in_nid;
 986
 987         spec->unsol_event = preset->unsol_event;
 988         spec->init_hook = preset->init_hook;
 989 #ifdef CONFIG_SND_HDA_POWER_SAVE
 990         spec->power_hook = preset->power_hook;
 991         spec->loopback.amplist = preset->loopbacks;
 992 #endif
 993
 994         if (preset->setup)
 995                 preset->setup(codec);
 996
 997         alc_fixup_autocfg_pin_nums(codec);
 998 }
 999
1000 /* Enable GPIO mask and set output */
1001 static const struct hda_verb alc_gpio1_init_verbs[] = {
1002         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
1003         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
1004         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
1005         { }
1006 };
1007
1008 static const struct hda_verb alc_gpio2_init_verbs[] = {
1009         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
1010         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
1011         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
1012         { }
1013 };
1014
1015 static const struct hda_verb alc_gpio3_init_verbs[] = {
1016         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
1017         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
1018         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
1019         { }
1020 };
1021
1022 /*
1023  * Fix hardware PLL issue
1024  * On some codecs, the analog PLL gating control must be off while
1025  * the default value is 1.
1026  */
1027 static void alc_fix_pll(struct hda_codec *codec)
1028 {
1029         struct alc_spec *spec = codec->spec;
1030         unsigned int val;
1031
1032         if (!spec->pll_nid)
1033                 return;
1034         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1035                             spec->pll_coef_idx);
1036         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
1037                                  AC_VERB_GET_PROC_COEF, 0);
1038         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1039                             spec->pll_coef_idx);
1040         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
1041                             val & ~(1 << spec->pll_coef_bit));
1042 }
1043
1044 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
1045                              unsigned int coef_idx, unsigned int coef_bit)
1046 {
1047         struct alc_spec *spec = codec->spec;
1048         spec->pll_nid = nid;
1049         spec->pll_coef_idx = coef_idx;
1050         spec->pll_coef_bit = coef_bit;
1051         alc_fix_pll(codec);
1052 }
1053
1054 static int alc_init_jacks(struct hda_codec *codec)
1055 {
1056 #ifdef CONFIG_SND_HDA_INPUT_JACK
1057         struct alc_spec *spec = codec->spec;
1058         int err;
1059         unsigned int hp_nid = spec->autocfg.hp_pins[0];
1060         unsigned int mic_nid = spec->ext_mic.pin;
1061         unsigned int dock_nid = spec->dock_mic.pin;
1062
1063         if (hp_nid) {
1064                 err = snd_hda_input_jack_add(codec, hp_nid,
1065                                              SND_JACK_HEADPHONE, NULL);
1066                 if (err < 0)
1067                         return err;
1068                 snd_hda_input_jack_report(codec, hp_nid);
1069         }
1070
1071         if (mic_nid) {
1072                 err = snd_hda_input_jack_add(codec, mic_nid,
1073                                              SND_JACK_MICROPHONE, NULL);
1074                 if (err < 0)
1075                         return err;
1076                 snd_hda_input_jack_report(codec, mic_nid);
1077         }
1078         if (dock_nid) {
1079                 err = snd_hda_input_jack_add(codec, dock_nid,
1080                                              SND_JACK_MICROPHONE, NULL);
1081                 if (err < 0)
1082                         return err;
1083                 snd_hda_input_jack_report(codec, dock_nid);
1084         }
1085 #endif /* CONFIG_SND_HDA_INPUT_JACK */
1086         return 0;
1087 }
1088
1089 static int detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
1090 {
1091         int i, present = 0;
1092
1093         for (i = 0; i < num_pins; i++) {
1094                 hda_nid_t nid = pins[i];
1095                 if (!nid)
1096                         break;
1097                 snd_hda_input_jack_report(codec, nid);
1098                 present |= snd_hda_jack_detect(codec, nid);
1099         }
1100         return present;
1101 }
1102
1103 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
1104                         bool mute, bool hp_out)
1105 {
1106         struct alc_spec *spec = codec->spec;
1107         unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0;
1108         unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);
1109         int i;
1110
1111         for (i = 0; i < num_pins; i++) {
1112                 hda_nid_t nid = pins[i];
1113                 if (!nid)
1114                         break;
1115                 switch (spec->automute_mode) {
1116                 case ALC_AUTOMUTE_PIN:
1117                         snd_hda_codec_write(codec, nid, 0,
1118                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1119                                             pin_bits);
1120                         break;
1121                 case ALC_AUTOMUTE_AMP:
1122                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1123                                                  HDA_AMP_MUTE, mute_bits);
1124                         break;
1125                 case ALC_AUTOMUTE_MIXER:
1126                         nid = spec->automute_mixer_nid[i];
1127                         if (!nid)
1128                                 break;
1129                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
1130                                                  HDA_AMP_MUTE, mute_bits);
1131                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1,
1132                                                  HDA_AMP_MUTE, mute_bits);
1133                         break;
1134                 }
1135         }
1136 }
1137
1138 /* Toggle internal speakers muting */
1139 static void update_speakers(struct hda_codec *codec)
1140 {
1141         struct alc_spec *spec = codec->spec;
1142         int on;
1143
1144         if (!spec->automute)
1145                 on = 0;
1146         else
1147                 on = spec->jack_present | spec->line_jack_present;
1148         on |= spec->master_mute;
1149         do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
1150                     spec->autocfg.speaker_pins, on, false);
1151
1152         /* toggle line-out mutes if needed, too */
1153         /* if LO is a copy of either HP or Speaker, don't need to handle it */
1154         if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
1155             spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
1156                 return;
1157         if (!spec->automute_lines || !spec->automute)
1158                 on = 0;
1159         else
1160                 on = spec->jack_present;
1161         on |= spec->master_mute;
1162         do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
1163                     spec->autocfg.line_out_pins, on, false);
1164 }
1165
1166 static void alc_hp_automute(struct hda_codec *codec)
1167 {
1168         struct alc_spec *spec = codec->spec;
1169
1170         if (!spec->automute)
1171                 return;
1172         spec->jack_present =
1173                 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
1174                              spec->autocfg.hp_pins);
1175         update_speakers(codec);
1176 }
1177
1178 static void alc_line_automute(struct hda_codec *codec)
1179 {
1180         struct alc_spec *spec = codec->spec;
1181
1182         if (!spec->automute || !spec->detect_line)
1183                 return;
1184         spec->line_jack_present =
1185                 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
1186                              spec->autocfg.line_out_pins);
1187         update_speakers(codec);
1188 }
1189
1190 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
1191                                 hda_nid_t nid)
1192 {
1193         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
1194         int i, nums;
1195
1196         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
1197         for (i = 0; i < nums; i++)
1198                 if (conn[i] == nid)
1199                         return i;
1200         return -1;
1201 }
1202
1203 /* switch the current ADC according to the jack state */
1204 static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec)
1205 {
1206         struct alc_spec *spec = codec->spec;
1207         unsigned int present;
1208         hda_nid_t new_adc;
1209
1210         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1211         if (present)
1212                 spec->cur_adc_idx = 1;
1213         else
1214                 spec->cur_adc_idx = 0;
1215         new_adc = spec->adc_nids[spec->cur_adc_idx];
1216         if (spec->cur_adc && spec->cur_adc != new_adc) {
1217                 /* stream is running, let's swap the current ADC */
1218                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1219                 spec->cur_adc = new_adc;
1220                 snd_hda_codec_setup_stream(codec, new_adc,
1221                                            spec->cur_adc_stream_tag, 0,
1222                                            spec->cur_adc_format);
1223         }
1224 }
1225
1226 static void alc_mic_automute(struct hda_codec *codec)
1227 {
1228         struct alc_spec *spec = codec->spec;
1229         struct alc_mic_route *dead1, *dead2, *alive;
1230         unsigned int present, type;
1231         hda_nid_t cap_nid;
1232
1233         if (!spec->auto_mic)
1234                 return;
1235         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1236                 return;
1237         if (snd_BUG_ON(!spec->adc_nids))
1238                 return;
1239
1240         if (spec->dual_adc_switch) {
1241                 alc_dual_mic_adc_auto_switch(codec);
1242                 return;
1243         }
1244
1245         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1246
1247         alive = &spec->int_mic;
1248         dead1 = &spec->ext_mic;
1249         dead2 = &spec->dock_mic;
1250
1251         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1252         if (present) {
1253                 alive = &spec->ext_mic;
1254                 dead1 = &spec->int_mic;
1255                 dead2 = &spec->dock_mic;
1256         }
1257         if (!present && spec->dock_mic.pin > 0) {
1258                 present = snd_hda_jack_detect(codec, spec->dock_mic.pin);
1259                 if (present) {
1260                         alive = &spec->dock_mic;
1261                         dead1 = &spec->int_mic;
1262                         dead2 = &spec->ext_mic;
1263                 }
1264                 snd_hda_input_jack_report(codec, spec->dock_mic.pin);
1265         }
1266
1267         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1268         if (type == AC_WID_AUD_MIX) {
1269                 /* Matrix-mixer style (e.g. ALC882) */
1270                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1271                                          alive->mux_idx,
1272                                          HDA_AMP_MUTE, 0);
1273                 if (dead1->pin > 0)
1274                         snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1275                                                  dead1->mux_idx,
1276                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
1277                 if (dead2->pin > 0)
1278                         snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1279                                                  dead2->mux_idx,
1280                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
1281         } else {
1282                 /* MUX style (e.g. ALC880) */
1283                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1284                                           AC_VERB_SET_CONNECT_SEL,
1285                                           alive->mux_idx);
1286         }
1287         snd_hda_input_jack_report(codec, spec->ext_mic.pin);
1288
1289         /* FIXME: analog mixer */
1290 }
1291
1292 /* unsolicited event for HP jack sensing */
1293 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1294 {
1295         if (codec->vendor_id == 0x10ec0880)
1296                 res >>= 28;
1297         else
1298                 res >>= 26;
1299         switch (res) {
1300         case ALC880_HP_EVENT:
1301                 alc_hp_automute(codec);
1302                 break;
1303         case ALC880_FRONT_EVENT:
1304                 alc_line_automute(codec);
1305                 break;
1306         case ALC880_MIC_EVENT:
1307                 alc_mic_automute(codec);
1308                 break;
1309         }
1310 }
1311
1312 static void alc_inithook(struct hda_codec *codec)
1313 {
1314         alc_hp_automute(codec);
1315         alc_line_automute(codec);
1316         alc_mic_automute(codec);
1317 }
1318
1319 /* additional initialization for ALC888 variants */
1320 static void alc888_coef_init(struct hda_codec *codec)
1321 {
1322         unsigned int tmp;
1323
1324         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1325         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1326         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1327         if ((tmp & 0xf0) == 0x20)
1328                 /* alc888S-VC */
1329                 snd_hda_codec_read(codec, 0x20, 0,
1330                                    AC_VERB_SET_PROC_COEF, 0x830);
1331          else
1332                  /* alc888-VB */
1333                  snd_hda_codec_read(codec, 0x20, 0,
1334                                     AC_VERB_SET_PROC_COEF, 0x3030);
1335 }
1336
1337 static void alc889_coef_init(struct hda_codec *codec)
1338 {
1339         unsigned int tmp;
1340
1341         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1342         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1343         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1344         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1345 }
1346
1347 /* turn on/off EAPD control (only if available) */
1348 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1349 {
1350         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1351                 return;
1352         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1353                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1354                                     on ? 2 : 0);
1355 }
1356
1357 /* turn on/off EAPD controls of the codec */
1358 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
1359 {
1360         /* We currently only handle front, HP */
1361         switch (codec->vendor_id) {
1362         case 0x10ec0260:
1363                 set_eapd(codec, 0x0f, on);
1364                 set_eapd(codec, 0x10, on);
1365                 break;
1366         case 0x10ec0262:
1367         case 0x10ec0267:
1368         case 0x10ec0268:
1369         case 0x10ec0269:
1370         case 0x10ec0270:
1371         case 0x10ec0272:
1372         case 0x10ec0660:
1373         case 0x10ec0662:
1374         case 0x10ec0663:
1375         case 0x10ec0665:
1376         case 0x10ec0862:
1377         case 0x10ec0889:
1378         case 0x10ec0892:
1379                 set_eapd(codec, 0x14, on);
1380                 set_eapd(codec, 0x15, on);
1381                 break;
1382         }
1383 }
1384
1385 /* generic shutup callback;
1386  * just turning off EPAD and a little pause for avoiding pop-noise
1387  */
1388 static void alc_eapd_shutup(struct hda_codec *codec)
1389 {
1390         alc_auto_setup_eapd(codec, false);
1391         msleep(200);
1392 }
1393
1394 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1395 {
1396         unsigned int tmp;
1397
1398         switch (type) {
1399         case ALC_INIT_GPIO1:
1400                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1401                 break;
1402         case ALC_INIT_GPIO2:
1403                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1404                 break;
1405         case ALC_INIT_GPIO3:
1406                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1407                 break;
1408         case ALC_INIT_DEFAULT:
1409                 alc_auto_setup_eapd(codec, true);
1410                 switch (codec->vendor_id) {
1411                 case 0x10ec0260:
1412                         snd_hda_codec_write(codec, 0x1a, 0,
1413                                             AC_VERB_SET_COEF_INDEX, 7);
1414                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1415                                                  AC_VERB_GET_PROC_COEF, 0);
1416                         snd_hda_codec_write(codec, 0x1a, 0,
1417                                             AC_VERB_SET_COEF_INDEX, 7);
1418                         snd_hda_codec_write(codec, 0x1a, 0,
1419                                             AC_VERB_SET_PROC_COEF,
1420                                             tmp | 0x2010);
1421                         break;
1422                 case 0x10ec0262:
1423                 case 0x10ec0880:
1424                 case 0x10ec0882:
1425                 case 0x10ec0883:
1426                 case 0x10ec0885:
1427                 case 0x10ec0887:
1428                 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
1429                         alc889_coef_init(codec);
1430                         break;
1431                 case 0x10ec0888:
1432                         alc888_coef_init(codec);
1433                         break;
1434 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
1435                 case 0x10ec0267:
1436                 case 0x10ec0268:
1437                         snd_hda_codec_write(codec, 0x20, 0,
1438                                             AC_VERB_SET_COEF_INDEX, 7);
1439                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1440                                                  AC_VERB_GET_PROC_COEF, 0);
1441                         snd_hda_codec_write(codec, 0x20, 0,
1442                                             AC_VERB_SET_COEF_INDEX, 7);
1443                         snd_hda_codec_write(codec, 0x20, 0,
1444                                             AC_VERB_SET_PROC_COEF,
1445                                             tmp | 0x3000);
1446                         break;
1447 #endif /* XXX */
1448                 }
1449                 break;
1450         }
1451 }
1452
1453 static int alc_automute_mode_info(struct snd_kcontrol *kcontrol,
1454                                   struct snd_ctl_elem_info *uinfo)
1455 {
1456         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1457         struct alc_spec *spec = codec->spec;
1458         static const char * const texts2[] = {
1459                 "Disabled", "Enabled"
1460         };
1461         static const char * const texts3[] = {
1462                 "Disabled", "Speaker Only", "Line-Out+Speaker"
1463         };
1464         const char * const *texts;
1465
1466         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1467         uinfo->count = 1;
1468         if (spec->automute_hp_lo) {
1469                 uinfo->value.enumerated.items = 3;
1470                 texts = texts3;
1471         } else {
1472                 uinfo->value.enumerated.items = 2;
1473                 texts = texts2;
1474         }
1475         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
1476                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
1477         strcpy(uinfo->value.enumerated.name,
1478                texts[uinfo->value.enumerated.item]);
1479         return 0;
1480 }
1481
1482 static int alc_automute_mode_get(struct snd_kcontrol *kcontrol,
1483                                  struct snd_ctl_elem_value *ucontrol)
1484 {
1485         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1486         struct alc_spec *spec = codec->spec;
1487         unsigned int val;
1488         if (!spec->automute)
1489                 val = 0;
1490         else if (!spec->automute_lines)
1491                 val = 1;
1492         else
1493                 val = 2;
1494         ucontrol->value.enumerated.item[0] = val;
1495         return 0;
1496 }
1497
1498 static int alc_automute_mode_put(struct snd_kcontrol *kcontrol,
1499                                  struct snd_ctl_elem_value *ucontrol)
1500 {
1501         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1502         struct alc_spec *spec = codec->spec;
1503
1504         switch (ucontrol->value.enumerated.item[0]) {
1505         case 0:
1506                 if (!spec->automute)
1507                         return 0;
1508                 spec->automute = 0;
1509                 break;
1510         case 1:
1511                 if (spec->automute && !spec->automute_lines)
1512                         return 0;
1513                 spec->automute = 1;
1514                 spec->automute_lines = 0;
1515                 break;
1516         case 2:
1517                 if (!spec->automute_hp_lo)
1518                         return -EINVAL;
1519                 if (spec->automute && spec->automute_lines)
1520                         return 0;
1521                 spec->automute = 1;
1522                 spec->automute_lines = 1;
1523                 break;
1524         default:
1525                 return -EINVAL;
1526         }
1527         update_speakers(codec);
1528         return 1;
1529 }
1530
1531 static const struct snd_kcontrol_new alc_automute_mode_enum = {
1532         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1533         .name = "Auto-Mute Mode",
1534         .info = alc_automute_mode_info,
1535         .get = alc_automute_mode_get,
1536         .put = alc_automute_mode_put,
1537 };
1538
1539 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec);
1540
1541 static int alc_add_automute_mode_enum(struct hda_codec *codec)
1542 {
1543         struct alc_spec *spec = codec->spec;
1544         struct snd_kcontrol_new *knew;
1545
1546         knew = alc_kcontrol_new(spec);
1547         if (!knew)
1548                 return -ENOMEM;
1549         *knew = alc_automute_mode_enum;
1550         knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
1551         if (!knew->name)
1552                 return -ENOMEM;
1553         return 0;
1554 }
1555
1556 static void alc_init_auto_hp(struct hda_codec *codec)
1557 {
1558         struct alc_spec *spec = codec->spec;
1559         struct auto_pin_cfg *cfg = &spec->autocfg;
1560         int present = 0;
1561         int i;
1562
1563         if (cfg->hp_pins[0])
1564                 present++;
1565         if (cfg->line_out_pins[0])
1566                 present++;
1567         if (cfg->speaker_pins[0])
1568                 present++;
1569         if (present < 2) /* need two different output types */
1570                 return;
1571         if (present == 3)
1572                 spec->automute_hp_lo = 1; /* both HP and LO automute */
1573
1574         if (!cfg->speaker_pins[0]) {
1575                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1576                        sizeof(cfg->speaker_pins));
1577                 cfg->speaker_outs = cfg->line_outs;
1578         }
1579
1580         if (!cfg->hp_pins[0]) {
1581                 memcpy(cfg->hp_pins, cfg->line_out_pins,
1582                        sizeof(cfg->hp_pins));
1583                 cfg->hp_outs = cfg->line_outs;
1584         }
1585
1586         for (i = 0; i < cfg->hp_outs; i++) {
1587                 hda_nid_t nid = cfg->hp_pins[i];
1588                 if (!is_jack_detectable(codec, nid))
1589                         continue;
1590                 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1591                             nid);
1592                 snd_hda_codec_write_cache(codec, nid, 0,
1593                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1594                                   AC_USRSP_EN | ALC880_HP_EVENT);
1595                 spec->automute = 1;
1596                 spec->automute_mode = ALC_AUTOMUTE_PIN;
1597         }
1598         if (spec->automute && cfg->line_out_pins[0] &&
1599             cfg->line_out_pins[0] != cfg->hp_pins[0] &&
1600             cfg->line_out_pins[0] != cfg->speaker_pins[0]) {
1601                 for (i = 0; i < cfg->line_outs; i++) {
1602                         hda_nid_t nid = cfg->line_out_pins[i];
1603                         if (!is_jack_detectable(codec, nid))
1604                                 continue;
1605                         snd_printdd("realtek: Enable Line-Out auto-muting "
1606                                     "on NID 0x%x\n", nid);
1607                         snd_hda_codec_write_cache(codec, nid, 0,
1608                                         AC_VERB_SET_UNSOLICITED_ENABLE,
1609                                         AC_USRSP_EN | ALC880_FRONT_EVENT);
1610                         spec->detect_line = 1;
1611                 }
1612                 spec->automute_lines = spec->detect_line;
1613         }
1614
1615         if (spec->automute) {
1616                 /* create a control for automute mode */
1617                 alc_add_automute_mode_enum(codec);
1618                 spec->unsol_event = alc_sku_unsol_event;
1619         }
1620 }
1621
1622 static void alc_init_auto_mic(struct hda_codec *codec)
1623 {
1624         struct alc_spec *spec = codec->spec;
1625         struct auto_pin_cfg *cfg = &spec->autocfg;
1626         hda_nid_t fixed, ext, dock;
1627         int i;
1628
1629         fixed = ext = dock = 0;
1630         for (i = 0; i < cfg->num_inputs; i++) {
1631                 hda_nid_t nid = cfg->inputs[i].pin;
1632                 unsigned int defcfg;
1633                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1634                 switch (snd_hda_get_input_pin_attr(defcfg)) {
1635                 case INPUT_PIN_ATTR_INT:
1636                         if (fixed)
1637                                 return; /* already occupied */
1638                         if (cfg->inputs[i].type != AUTO_PIN_MIC)
1639                                 return; /* invalid type */
1640                         fixed = nid;
1641                         break;
1642                 case INPUT_PIN_ATTR_UNUSED:
1643                         return; /* invalid entry */
1644                 case INPUT_PIN_ATTR_DOCK:
1645                         if (dock)
1646                                 return; /* already occupied */
1647                         if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
1648                                 return; /* invalid type */
1649                         dock = nid;
1650                         break;
1651                 default:
1652                         if (ext)
1653                                 return; /* already occupied */
1654                         if (cfg->inputs[i].type != AUTO_PIN_MIC)
1655                                 return; /* invalid type */
1656                         ext = nid;
1657                         break;
1658                 }
1659         }
1660         if (!ext && dock) {
1661                 ext = dock;
1662                 dock = 0;
1663         }
1664         if (!ext || !fixed)
1665                 return;
1666         if (!is_jack_detectable(codec, ext))
1667                 return; /* no unsol support */
1668         if (dock && !is_jack_detectable(codec, dock))
1669                 return; /* no unsol support */
1670         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
1671                     ext, fixed, dock);
1672         spec->ext_mic.pin = ext;
1673         spec->dock_mic.pin = dock;
1674         spec->int_mic.pin = fixed;
1675         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1676         spec->dock_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1677         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1678         spec->auto_mic = 1;
1679         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1680                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1681                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1682         spec->unsol_event = alc_sku_unsol_event;
1683 }
1684
1685 /* Could be any non-zero and even value. When used as fixup, tells
1686  * the driver to ignore any present sku defines.
1687  */
1688 #define ALC_FIXUP_SKU_IGNORE (2)
1689
1690 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1691 {
1692         unsigned int ass, tmp, i;
1693         unsigned nid = 0;
1694         struct alc_spec *spec = codec->spec;
1695
1696         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1697
1698         if (spec->cdefine.fixup) {
1699                 ass = spec->cdefine.sku_cfg;
1700                 if (ass == ALC_FIXUP_SKU_IGNORE)
1701                         return -1;
1702                 goto do_sku;
1703         }
1704
1705         ass = codec->subsystem_id & 0xffff;
1706         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1707                 goto do_sku;
1708
1709         nid = 0x1d;
1710         if (codec->vendor_id == 0x10ec0260)
1711                 nid = 0x17;
1712         ass = snd_hda_codec_get_pincfg(codec, nid);
1713
1714         if (!(ass & 1)) {
1715                 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1716                        codec->chip_name, ass);
1717                 return -1;
1718         }
1719
1720         /* check sum */
1721         tmp = 0;
1722         for (i = 1; i < 16; i++) {
1723                 if ((ass >> i) & 1)
1724                         tmp++;
1725         }
1726         if (((ass >> 16) & 0xf) != tmp)
1727                 return -1;
1728
1729         spec->cdefine.port_connectivity = ass >> 30;
1730         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1731         spec->cdefine.check_sum = (ass >> 16) & 0xf;
1732         spec->cdefine.customization = ass >> 8;
1733 do_sku:
1734         spec->cdefine.sku_cfg = ass;
1735         spec->cdefine.external_amp = (ass & 0x38) >> 3;
1736         spec->cdefine.platform_type = (ass & 0x4) >> 2;
1737         spec->cdefine.swap = (ass & 0x2) >> 1;
1738         spec->cdefine.override = ass & 0x1;
1739
1740         snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1741                    nid, spec->cdefine.sku_cfg);
1742         snd_printd("SKU: port_connectivity=0x%x\n",
1743                    spec->cdefine.port_connectivity);
1744         snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1745         snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1746         snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1747         snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1748         snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1749         snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1750         snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1751
1752         return 0;
1753 }
1754
1755 /* check subsystem ID and set up device-specific initialization;
1756  * return 1 if initialized, 0 if invalid SSID
1757  */
1758 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1759  *      31 ~ 16 :       Manufacture ID
1760  *      15 ~ 8  :       SKU ID
1761  *      7  ~ 0  :       Assembly ID
1762  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1763  */
1764 static int alc_subsystem_id(struct hda_codec *codec,
1765                             hda_nid_t porta, hda_nid_t porte,
1766                             hda_nid_t portd, hda_nid_t porti)
1767 {
1768         unsigned int ass, tmp, i;
1769         unsigned nid;
1770         struct alc_spec *spec = codec->spec;
1771
1772         if (spec->cdefine.fixup) {
1773                 ass = spec->cdefine.sku_cfg;
1774                 if (ass == ALC_FIXUP_SKU_IGNORE)
1775                         return 0;
1776                 goto do_sku;
1777         }
1778
1779         ass = codec->subsystem_id & 0xffff;
1780         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1781                 goto do_sku;
1782
1783         /* invalid SSID, check the special NID pin defcfg instead */
1784         /*
1785          * 31~30        : port connectivity
1786          * 29~21        : reserve
1787          * 20           : PCBEEP input
1788          * 19~16        : Check sum (15:1)
1789          * 15~1         : Custom
1790          * 0            : override
1791         */
1792         nid = 0x1d;
1793         if (codec->vendor_id == 0x10ec0260)
1794                 nid = 0x17;
1795         ass = snd_hda_codec_get_pincfg(codec, nid);
1796         snd_printd("realtek: No valid SSID, "
1797                    "checking pincfg 0x%08x for NID 0x%x\n",
1798                    ass, nid);
1799         if (!(ass & 1))
1800                 return 0;
1801         if ((ass >> 30) != 1)   /* no physical connection */
1802                 return 0;
1803
1804         /* check sum */
1805         tmp = 0;
1806         for (i = 1; i < 16; i++) {
1807                 if ((ass >> i) & 1)
1808                         tmp++;
1809         }
1810         if (((ass >> 16) & 0xf) != tmp)
1811                 return 0;
1812 do_sku:
1813         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1814                    ass & 0xffff, codec->vendor_id);
1815         /*
1816          * 0 : override
1817          * 1 :  Swap Jack
1818          * 2 : 0 --> Desktop, 1 --> Laptop
1819          * 3~5 : External Amplifier control
1820          * 7~6 : Reserved
1821         */
1822         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1823         switch (tmp) {
1824         case 1:
1825                 spec->init_amp = ALC_INIT_GPIO1;
1826                 break;
1827         case 3:
1828                 spec->init_amp = ALC_INIT_GPIO2;
1829                 break;
1830         case 7:
1831                 spec->init_amp = ALC_INIT_GPIO3;
1832                 break;
1833         case 5:
1834         default:
1835                 spec->init_amp = ALC_INIT_DEFAULT;
1836                 break;
1837         }
1838
1839         /* is laptop or Desktop and enable the function "Mute internal speaker
1840          * when the external headphone out jack is plugged"
1841          */
1842         if (!(ass & 0x8000))
1843                 return 1;
1844         /*
1845          * 10~8 : Jack location
1846          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1847          * 14~13: Resvered
1848          * 15   : 1 --> enable the function "Mute internal speaker
1849          *              when the external headphone out jack is plugged"
1850          */
1851         if (!spec->autocfg.hp_pins[0]) {
1852                 hda_nid_t nid;
1853                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1854                 if (tmp == 0)
1855                         nid = porta;
1856                 else if (tmp == 1)
1857                         nid = porte;
1858                 else if (tmp == 2)
1859                         nid = portd;
1860                 else if (tmp == 3)
1861                         nid = porti;
1862                 else
1863                         return 1;
1864                 for (i = 0; i < spec->autocfg.line_outs; i++)
1865                         if (spec->autocfg.line_out_pins[i] == nid)
1866                                 return 1;
1867                 spec->autocfg.hp_pins[0] = nid;
1868         }
1869         return 1;
1870 }
1871
1872 static void alc_ssid_check(struct hda_codec *codec,
1873                            hda_nid_t porta, hda_nid_t porte,
1874                            hda_nid_t portd, hda_nid_t porti)
1875 {
1876         if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1877                 struct alc_spec *spec = codec->spec;
1878                 snd_printd("realtek: "
1879                            "Enable default setup for auto mode as fallback\n");
1880                 spec->init_amp = ALC_INIT_DEFAULT;
1881         }
1882
1883         alc_init_auto_hp(codec);
1884         alc_init_auto_mic(codec);
1885 }
1886
1887 /*
1888  * Fix-up pin default configurations and add default verbs
1889  */
1890
1891 struct alc_pincfg {
1892         hda_nid_t nid;
1893         u32 val;
1894 };
1895
1896 struct alc_model_fixup {
1897         const int id;
1898         const char *name;
1899 };
1900
1901 struct alc_fixup {
1902         int type;
1903         bool chained;
1904         int chain_id;
1905         union {
1906                 unsigned int sku;
1907                 const struct alc_pincfg *pins;
1908                 const struct hda_verb *verbs;
1909                 void (*func)(struct hda_codec *codec,
1910                              const struct alc_fixup *fix,
1911                              int action);
1912         } v;
1913 };
1914
1915 enum {
1916         ALC_FIXUP_INVALID,
1917         ALC_FIXUP_SKU,
1918         ALC_FIXUP_PINS,
1919         ALC_FIXUP_VERBS,
1920         ALC_FIXUP_FUNC,
1921 };
1922
1923 enum {
1924         ALC_FIXUP_ACT_PRE_PROBE,
1925         ALC_FIXUP_ACT_PROBE,
1926         ALC_FIXUP_ACT_INIT,
1927 };
1928
1929 static void alc_apply_fixup(struct hda_codec *codec, int action)
1930 {
1931         struct alc_spec *spec = codec->spec;
1932         int id = spec->fixup_id;
1933 #ifdef CONFIG_SND_DEBUG_VERBOSE
1934         const char *modelname = spec->fixup_name;
1935 #endif
1936         int depth = 0;
1937
1938         if (!spec->fixup_list)
1939                 return;
1940
1941         while (id >= 0) {
1942                 const struct alc_fixup *fix = spec->fixup_list + id;
1943                 const struct alc_pincfg *cfg;
1944
1945                 switch (fix->type) {
1946                 case ALC_FIXUP_SKU:
1947                         if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1948                                 break;;
1949                         snd_printdd(KERN_INFO "hda_codec: %s: "
1950                                     "Apply sku override for %s\n",
1951                                     codec->chip_name, modelname);
1952                         spec->cdefine.sku_cfg = fix->v.sku;
1953                         spec->cdefine.fixup = 1;
1954                         break;
1955                 case ALC_FIXUP_PINS:
1956                         cfg = fix->v.pins;
1957                         if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1958                                 break;
1959                         snd_printdd(KERN_INFO "hda_codec: %s: "
1960                                     "Apply pincfg for %s\n",
1961                                     codec->chip_name, modelname);
1962                         for (; cfg->nid; cfg++)
1963                                 snd_hda_codec_set_pincfg(codec, cfg->nid,
1964                                                          cfg->val);
1965                         break;
1966                 case ALC_FIXUP_VERBS:
1967                         if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1968                                 break;
1969                         snd_printdd(KERN_INFO "hda_codec: %s: "
1970                                     "Apply fix-verbs for %s\n",
1971                                     codec->chip_name, modelname);
1972                         add_verb(codec->spec, fix->v.verbs);
1973                         break;
1974                 case ALC_FIXUP_FUNC:
1975                         if (!fix->v.func)
1976                                 break;
1977                         snd_printdd(KERN_INFO "hda_codec: %s: "
1978                                     "Apply fix-func for %s\n",
1979                                     codec->chip_name, modelname);
1980                         fix->v.func(codec, fix, action);
1981                         break;
1982                 default:
1983                         snd_printk(KERN_ERR "hda_codec: %s: "
1984                                    "Invalid fixup type %d\n",
1985                                    codec->chip_name, fix->type);
1986                         break;
1987                 }
1988                 if (!fix->chained)
1989                         break;
1990                 if (++depth > 10)
1991                         break;
1992                 id = fix->chain_id;
1993         }
1994 }
1995
1996 static void alc_pick_fixup(struct hda_codec *codec,
1997                            const struct alc_model_fixup *models,
1998                            const struct snd_pci_quirk *quirk,
1999                            const struct alc_fixup *fixlist)
2000 {
2001         struct alc_spec *spec = codec->spec;
2002         int id = -1;
2003         const char *name = NULL;
2004
2005         if (codec->modelname && models) {
2006                 while (models->name) {
2007                         if (!strcmp(codec->modelname, models->name)) {
2008                                 id = models->id;
2009                                 name = models->name;
2010                                 break;
2011                         }
2012                         models++;
2013                 }
2014         }
2015         if (id < 0) {
2016                 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
2017                 if (quirk) {
2018                         id = quirk->value;
2019 #ifdef CONFIG_SND_DEBUG_VERBOSE
2020                         name = quirk->name;
2021 #endif
2022                 }
2023         }
2024
2025         spec->fixup_id = id;
2026         if (id >= 0) {
2027                 spec->fixup_list = fixlist;
2028                 spec->fixup_name = name;
2029         }
2030 }
2031
2032 static int alc_read_coef_idx(struct hda_codec *codec,
2033                         unsigned int coef_idx)
2034 {
2035         unsigned int val;
2036         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
2037                                 coef_idx);
2038         val = snd_hda_codec_read(codec, 0x20, 0,
2039                                 AC_VERB_GET_PROC_COEF, 0);
2040         return val;
2041 }
2042
2043 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
2044                                                         unsigned int coef_val)
2045 {
2046         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
2047                             coef_idx);
2048         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
2049                             coef_val);
2050 }
2051
2052 /* set right pin controls for digital I/O */
2053 static void alc_auto_init_digital(struct hda_codec *codec)
2054 {
2055         struct alc_spec *spec = codec->spec;
2056         int i;
2057         hda_nid_t pin;
2058
2059         for (i = 0; i < spec->autocfg.dig_outs; i++) {
2060                 pin = spec->autocfg.dig_out_pins[i];
2061                 if (pin) {
2062                         snd_hda_codec_write(codec, pin, 0,
2063                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
2064                                             PIN_OUT);
2065                 }
2066         }
2067         pin = spec->autocfg.dig_in_pin;
2068         if (pin)
2069                 snd_hda_codec_write(codec, pin, 0,
2070                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
2071                                     PIN_IN);
2072 }
2073
2074 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
2075 static void alc_auto_parse_digital(struct hda_codec *codec)
2076 {
2077         struct alc_spec *spec = codec->spec;
2078         int i, err;
2079         hda_nid_t dig_nid;
2080
2081         /* support multiple SPDIFs; the secondary is set up as a slave */
2082         for (i = 0; i < spec->autocfg.dig_outs; i++) {
2083                 err = snd_hda_get_connections(codec,
2084                                               spec->autocfg.dig_out_pins[i],
2085                                               &dig_nid, 1);
2086                 if (err < 0)
2087                         continue;
2088                 if (!i) {
2089                         spec->multiout.dig_out_nid = dig_nid;
2090                         spec->dig_out_type = spec->autocfg.dig_out_type[0];
2091                 } else {
2092                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
2093                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
2094                                 break;
2095                         spec->slave_dig_outs[i - 1] = dig_nid;
2096                 }
2097         }
2098
2099         if (spec->autocfg.dig_in_pin) {
2100                 dig_nid = codec->start_nid;
2101                 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
2102                         unsigned int wcaps = get_wcaps(codec, dig_nid);
2103                         if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
2104                                 continue;
2105                         if (!(wcaps & AC_WCAP_DIGITAL))
2106                                 continue;
2107                         if (!(wcaps & AC_WCAP_CONN_LIST))
2108                                 continue;
2109                         err = get_connection_index(codec, dig_nid,
2110                                                    spec->autocfg.dig_in_pin);
2111                         if (err >= 0) {
2112                                 spec->dig_in_nid = dig_nid;
2113                                 break;
2114                         }
2115                 }
2116         }
2117 }
2118
2119 /*
2120  * ALC888
2121  */
2122
2123 /*
2124  * 2ch mode
2125  */
2126 static const struct hda_verb alc888_4ST_ch2_intel_init[] = {
2127 /* Mic-in jack as mic in */
2128         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2129         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2130 /* Line-in jack as Line in */
2131         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2132         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2133 /* Line-Out as Front */
2134         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
2135         { } /* end */
2136 };
2137
2138 /*
2139  * 4ch mode
2140  */
2141 static const struct hda_verb alc888_4ST_ch4_intel_init[] = {
2142 /* Mic-in jack as mic in */
2143         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2144         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2145 /* Line-in jack as Surround */
2146         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2147         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2148 /* Line-Out as Front */
2149         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
2150         { } /* end */
2151 };
2152
2153 /*
2154  * 6ch mode
2155  */
2156 static const struct hda_verb alc888_4ST_ch6_intel_init[] = {
2157 /* Mic-in jack as CLFE */
2158         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2159         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2160 /* Line-in jack as Surround */
2161         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2162         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2163 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
2164         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
2165         { } /* end */
2166 };
2167
2168 /*
2169  * 8ch mode
2170  */
2171 static const struct hda_verb alc888_4ST_ch8_intel_init[] = {
2172 /* Mic-in jack as CLFE */
2173         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2174         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2175 /* Line-in jack as Surround */
2176         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2177         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2178 /* Line-Out as Side */
2179         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
2180         { } /* end */
2181 };
2182
2183 static const struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
2184         { 2, alc888_4ST_ch2_intel_init },
2185         { 4, alc888_4ST_ch4_intel_init },
2186         { 6, alc888_4ST_ch6_intel_init },
2187         { 8, alc888_4ST_ch8_intel_init },
2188 };
2189
2190 /*
2191  * ALC888 Fujitsu Siemens Amillo xa3530
2192  */
2193
2194 static const struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
2195 /* Front Mic: set to PIN_IN (empty by default) */
2196         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2197 /* Connect Internal HP to Front */
2198         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2199         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2200         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2201 /* Connect Bass HP to Front */
2202         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2203         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2204         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2205 /* Connect Line-Out side jack (SPDIF) to Side */
2206         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2207         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2208         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
2209 /* Connect Mic jack to CLFE */
2210         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2211         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2212         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
2213 /* Connect Line-in jack to Surround */
2214         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2215         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2216         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
2217 /* Connect HP out jack to Front */
2218         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2219         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2220         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2221 /* Enable unsolicited event for HP jack and Line-out jack */
2222         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2223         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2224         {}
2225 };
2226
2227 static void alc889_automute_setup(struct hda_codec *codec)
2228 {
2229         struct alc_spec *spec = codec->spec;
2230
2231         spec->autocfg.hp_pins[0] = 0x15;
2232         spec->autocfg.speaker_pins[0] = 0x14;
2233         spec->autocfg.speaker_pins[1] = 0x16;
2234         spec->autocfg.speaker_pins[2] = 0x17;
2235         spec->autocfg.speaker_pins[3] = 0x19;
2236         spec->autocfg.speaker_pins[4] = 0x1a;
2237         spec->automute = 1;
2238         spec->automute_mode = ALC_AUTOMUTE_AMP;
2239 }
2240
2241 static void alc889_intel_init_hook(struct hda_codec *codec)
2242 {
2243         alc889_coef_init(codec);
2244         alc_hp_automute(codec);
2245 }
2246
2247 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
2248 {
2249         struct alc_spec *spec = codec->spec;
2250
2251         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
2252         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
2253         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
2254         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
2255         spec->automute = 1;
2256         spec->automute_mode = ALC_AUTOMUTE_AMP;
2257 }
2258
2259 /*
2260  * ALC888 Acer Aspire 4930G model
2261  */
2262
2263 static const struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
2264 /* Front Mic: set to PIN_IN (empty by default) */
2265         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2266 /* Unselect Front Mic by default in input mixer 3 */
2267         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2268 /* Enable unsolicited event for HP jack */
2269         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2270 /* Connect Internal HP to front */
2271         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2272         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2273         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2274 /* Connect HP out to front */
2275         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2276         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2277         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2278         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2279         { }
2280 };
2281
2282 /*
2283  * ALC888 Acer Aspire 6530G model
2284  */
2285
2286 static const struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
2287 /* Route to built-in subwoofer as well as speakers */
2288         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2289         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2290         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2291         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2292 /* Bias voltage on for external mic port */
2293         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2294 /* Front Mic: set to PIN_IN (empty by default) */
2295         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2296 /* Unselect Front Mic by default in input mixer 3 */
2297         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2298 /* Enable unsolicited event for HP jack */
2299         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2300 /* Enable speaker output */
2301         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2302         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2303         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2304 /* Enable headphone output */
2305         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2306         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2307         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2308         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2309         { }
2310 };
2311
2312 /*
2313  *ALC888 Acer Aspire 7730G model
2314  */
2315
2316 static const struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
2317 /* Bias voltage on for external mic port */
2318         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2319 /* Front Mic: set to PIN_IN (empty by default) */
2320         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2321 /* Unselect Front Mic by default in input mixer 3 */
2322         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2323 /* Enable unsolicited event for HP jack */
2324         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2325 /* Enable speaker output */
2326         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2327         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2328         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2329 /* Enable headphone output */
2330         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2331         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2332         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2333         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2334 /*Enable internal subwoofer */
2335         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2336         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2337         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
2338         {0x17, AC_VERB_SET_EAPD_BTLENABLE, 2},
2339         { }
2340 };
2341
2342 /*
2343  * ALC889 Acer Aspire 8930G model
2344  */
2345
2346 static const struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
2347 /* Front Mic: set to PIN_IN (empty by default) */
2348         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2349 /* Unselect Front Mic by default in input mixer 3 */
2350         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2351 /* Enable unsolicited event for HP jack */
2352         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2353 /* Connect Internal Front to Front */
2354         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2355         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2356         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2357 /* Connect Internal Rear to Rear */
2358         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2359         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2360         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
2361 /* Connect Internal CLFE to CLFE */
2362         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2363         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2364         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
2365 /* Connect HP out to Front */
2366         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2367         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2368         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2369 /* Enable all DACs */
2370 /*  DAC DISABLE/MUTE 1? */
2371 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
2372         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
2373         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2374 /*  DAC DISABLE/MUTE 2? */
2375 /*  some bit here disables the other DACs. Init=0x4900 */
2376         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
2377         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2378 /* DMIC fix
2379  * This laptop has a stereo digital microphone. The mics are only 1cm apart
2380  * which makes the stereo useless. However, either the mic or the ALC889
2381  * makes the signal become a difference/sum signal instead of standard
2382  * stereo, which is annoying. So instead we flip this bit which makes the
2383  * codec replicate the sum signal to both channels, turning it into a
2384  * normal mono mic.
2385  */
2386 /*  DMIC_CONTROL? Init value = 0x0001 */
2387         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
2388         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
2389         { }
2390 };
2391
2392 static const struct hda_input_mux alc888_2_capture_sources[2] = {
2393         /* Front mic only available on one ADC */
2394         {
2395                 .num_items = 4,
2396                 .items = {
2397                         { "Mic", 0x0 },
2398                         { "Line", 0x2 },
2399                         { "CD", 0x4 },
2400                         { "Front Mic", 0xb },
2401                 },
2402         },
2403         {
2404                 .num_items = 3,
2405                 .items = {
2406                         { "Mic", 0x0 },
2407                         { "Line", 0x2 },
2408                         { "CD", 0x4 },
2409                 },
2410         }
2411 };
2412
2413 static const struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
2414         /* Interal mic only available on one ADC */
2415         {
2416                 .num_items = 5,
2417                 .items = {
2418                         { "Mic", 0x0 },
2419                         { "Line In", 0x2 },
2420                         { "CD", 0x4 },
2421                         { "Input Mix", 0xa },
2422                         { "Internal Mic", 0xb },
2423                 },
2424         },
2425         {
2426                 .num_items = 4,
2427                 .items = {
2428                         { "Mic", 0x0 },
2429                         { "Line In", 0x2 },
2430                         { "CD", 0x4 },
2431                         { "Input Mix", 0xa },
2432                 },
2433         }
2434 };
2435
2436 static const struct hda_input_mux alc889_capture_sources[3] = {
2437         /* Digital mic only available on first "ADC" */
2438         {
2439                 .num_items = 5,
2440                 .items = {
2441                         { "Mic", 0x0 },
2442                         { "Line", 0x2 },
2443                         { "CD", 0x4 },
2444                         { "Front Mic", 0xb },
2445                         { "Input Mix", 0xa },
2446                 },
2447         },
2448         {
2449                 .num_items = 4,
2450                 .items = {
2451                         { "Mic", 0x0 },
2452                         { "Line", 0x2 },
2453                         { "CD", 0x4 },
2454                         { "Input Mix", 0xa },
2455                 },
2456         },
2457         {
2458                 .num_items = 4,
2459                 .items = {
2460                         { "Mic", 0x0 },
2461                         { "Line", 0x2 },
2462                         { "CD", 0x4 },
2463                         { "Input Mix", 0xa },
2464                 },
2465         }
2466 };
2467
2468 static const struct snd_kcontrol_new alc888_base_mixer[] = {
2469         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2470         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2471         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2472         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2473         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2474                 HDA_OUTPUT),
2475         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2476         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2477         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2478         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2479         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2480         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2481         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2482         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2483         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2484         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2485         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2486         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2487         { } /* end */
2488 };
2489
2490 static const struct snd_kcontrol_new alc888_acer_aspire_4930g_mixer[] = {
2491         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2492         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2493         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2494         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2495         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2496                 HDA_OUTPUT),
2497         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2498         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2499         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2500         HDA_CODEC_VOLUME_MONO("Internal LFE Playback Volume", 0x0f, 1, 0x0, HDA_OUTPUT),
2501         HDA_BIND_MUTE_MONO("Internal LFE Playback Switch", 0x0f, 1, 2, HDA_INPUT),
2502         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2503         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2504         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2505         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2506         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2507         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2508         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2509         { } /* end */
2510 };
2511
2512 static const struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
2513         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2514         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2515         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2516         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2517         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2518                 HDA_OUTPUT),
2519         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2520         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2521         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2522         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2523         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2524         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2525         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2526         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2527         { } /* end */
2528 };
2529
2530
2531 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
2532 {
2533         struct alc_spec *spec = codec->spec;
2534
2535         spec->autocfg.hp_pins[0] = 0x15;
2536         spec->autocfg.speaker_pins[0] = 0x14;
2537         spec->autocfg.speaker_pins[1] = 0x16;
2538         spec->autocfg.speaker_pins[2] = 0x17;
2539         spec->automute = 1;
2540         spec->automute_mode = ALC_AUTOMUTE_AMP;
2541 }
2542
2543 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
2544 {
2545         struct alc_spec *spec = codec->spec;
2546
2547         spec->autocfg.hp_pins[0] = 0x15;
2548         spec->autocfg.speaker_pins[0] = 0x14;
2549         spec->autocfg.speaker_pins[1] = 0x16;
2550         spec->autocfg.speaker_pins[2] = 0x17;
2551         spec->automute = 1;
2552         spec->automute_mode = ALC_AUTOMUTE_AMP;
2553 }
2554
2555 static void alc888_acer_aspire_7730g_setup(struct hda_codec *codec)
2556 {
2557         struct alc_spec *spec = codec->spec;
2558
2559         spec->autocfg.hp_pins[0] = 0x15;
2560         spec->autocfg.speaker_pins[0] = 0x14;
2561         spec->autocfg.speaker_pins[1] = 0x16;
2562         spec->autocfg.speaker_pins[2] = 0x17;
2563         spec->automute = 1;
2564         spec->automute_mode = ALC_AUTOMUTE_AMP;
2565 }
2566
2567 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
2568 {
2569         struct alc_spec *spec = codec->spec;
2570
2571         spec->autocfg.hp_pins[0] = 0x15;
2572         spec->autocfg.speaker_pins[0] = 0x14;
2573         spec->autocfg.speaker_pins[1] = 0x16;
2574         spec->autocfg.speaker_pins[2] = 0x1b;
2575         spec->automute = 1;
2576         spec->automute_mode = ALC_AUTOMUTE_AMP;
2577 }
2578
2579 /*
2580  * ALC880 3-stack model
2581  *
2582  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
2583  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
2584  *                 F-Mic = 0x1b, HP = 0x19
2585  */
2586
2587 static const hda_nid_t alc880_dac_nids[4] = {
2588         /* front, rear, clfe, rear_surr */
2589         0x02, 0x05, 0x04, 0x03
2590 };
2591
2592 static const hda_nid_t alc880_adc_nids[3] = {
2593         /* ADC0-2 */
2594         0x07, 0x08, 0x09,
2595 };
2596
2597 /* The datasheet says the node 0x07 is connected from inputs,
2598  * but it shows zero connection in the real implementation on some devices.
2599  * Note: this is a 915GAV bug, fixed on 915GLV
2600  */
2601 static const hda_nid_t alc880_adc_nids_alt[2] = {
2602         /* ADC1-2 */
2603         0x08, 0x09,
2604 };
2605
2606 #define ALC880_DIGOUT_NID       0x06
2607 #define ALC880_DIGIN_NID        0x0a
2608
2609 static const struct hda_input_mux alc880_capture_source = {
2610         .num_items = 4,
2611         .items = {
2612                 { "Mic", 0x0 },
2613                 { "Front Mic", 0x3 },
2614                 { "Line", 0x2 },
2615                 { "CD", 0x4 },
2616         },
2617 };
2618
2619 /* channel source setting (2/6 channel selection for 3-stack) */
2620 /* 2ch mode */
2621 static const struct hda_verb alc880_threestack_ch2_init[] = {
2622         /* set line-in to input, mute it */
2623         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2624         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2625         /* set mic-in to input vref 80%, mute it */
2626         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2627         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2628         { } /* end */
2629 };
2630
2631 /* 6ch mode */
2632 static const struct hda_verb alc880_threestack_ch6_init[] = {
2633         /* set line-in to output, unmute it */
2634         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2635         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2636         /* set mic-in to output, unmute it */
2637         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2638         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2639         { } /* end */
2640 };
2641
2642 static const struct hda_channel_mode alc880_threestack_modes[2] = {
2643         { 2, alc880_threestack_ch2_init },
2644         { 6, alc880_threestack_ch6_init },
2645 };
2646
2647 static const struct snd_kcontrol_new alc880_three_stack_mixer[] = {
2648         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2649         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2650         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2651         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2652         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2653         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2654         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2655         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2656         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2657         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2658         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2659         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2660         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2661         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2662         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
2663         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
2664         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
2665         {
2666                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2667                 .name = "Channel Mode",
2668                 .info = alc_ch_mode_info,
2669                 .get = alc_ch_mode_get,
2670                 .put = alc_ch_mode_put,
2671         },
2672         { } /* end */
2673 };
2674
2675 /* capture mixer elements */
2676 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
2677                             struct snd_ctl_elem_info *uinfo)
2678 {
2679         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2680         struct alc_spec *spec = codec->spec;
2681         int err;
2682
2683         mutex_lock(&codec->control_mutex);
2684         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2685                                                       HDA_INPUT);
2686         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
2687         mutex_unlock(&codec->control_mutex);
2688         return err;
2689 }
2690
2691 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2692                            unsigned int size, unsigned int __user *tlv)
2693 {
2694         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2695         struct alc_spec *spec = codec->spec;
2696         int err;
2697
2698         mutex_lock(&codec->control_mutex);
2699         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2700                                                       HDA_INPUT);
2701         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
2702         mutex_unlock(&codec->control_mutex);
2703         return err;
2704 }
2705
2706 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
2707                              struct snd_ctl_elem_value *ucontrol);
2708
2709 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
2710                                  struct snd_ctl_elem_value *ucontrol,
2711                                  getput_call_t func)
2712 {
2713         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2714         struct alc_spec *spec = codec->spec;
2715         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2716         int err;
2717
2718         mutex_lock(&codec->control_mutex);
2719         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
2720                                                       3, 0, HDA_INPUT);
2721         err = func(kcontrol, ucontrol);
2722         mutex_unlock(&codec->control_mutex);
2723         return err;
2724 }
2725
2726 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
2727                            struct snd_ctl_elem_value *ucontrol)
2728 {
2729         return alc_cap_getput_caller(kcontrol, ucontrol,
2730                                      snd_hda_mixer_amp_volume_get);
2731 }
2732
2733 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2734                            struct snd_ctl_elem_value *ucontrol)
2735 {
2736         return alc_cap_getput_caller(kcontrol, ucontrol,
2737                                      snd_hda_mixer_amp_volume_put);
2738 }
2739
2740 /* capture mixer elements */
2741 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2742
2743 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2744                           struct snd_ctl_elem_value *ucontrol)
2745 {
2746         return alc_cap_getput_caller(kcontrol, ucontrol,
2747                                      snd_hda_mixer_amp_switch_get);
2748 }
2749
2750 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2751                           struct snd_ctl_elem_value *ucontrol)
2752 {
2753         return alc_cap_getput_caller(kcontrol, ucontrol,
2754                                      snd_hda_mixer_amp_switch_put);
2755 }
2756
2757 #define _DEFINE_CAPMIX(num) \
2758         { \
2759                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2760                 .name = "Capture Switch", \
2761                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2762                 .count = num, \
2763                 .info = alc_cap_sw_info, \
2764                 .get = alc_cap_sw_get, \
2765                 .put = alc_cap_sw_put, \
2766         }, \
2767         { \
2768                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2769                 .name = "Capture Volume", \
2770                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2771                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2772                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2773                 .count = num, \
2774                 .info = alc_cap_vol_info, \
2775                 .get = alc_cap_vol_get, \
2776                 .put = alc_cap_vol_put, \
2777                 .tlv = { .c = alc_cap_vol_tlv }, \
2778         }
2779
2780 #define _DEFINE_CAPSRC(num) \
2781         { \
2782                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2783                 /* .name = "Capture Source", */ \
2784                 .name = "Input Source", \
2785                 .count = num, \
2786                 .info = alc_mux_enum_info, \
2787                 .get = alc_mux_enum_get, \
2788                 .put = alc_mux_enum_put, \
2789         }
2790
2791 #define DEFINE_CAPMIX(num) \
2792 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2793         _DEFINE_CAPMIX(num),                                  \
2794         _DEFINE_CAPSRC(num),                                  \
2795         { } /* end */                                         \
2796 }
2797
2798 #define DEFINE_CAPMIX_NOSRC(num) \
2799 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2800         _DEFINE_CAPMIX(num),                                        \
2801         { } /* end */                                               \
2802 }
2803
2804 /* up to three ADCs */
2805 DEFINE_CAPMIX(1);
2806 DEFINE_CAPMIX(2);
2807 DEFINE_CAPMIX(3);
2808 DEFINE_CAPMIX_NOSRC(1);
2809 DEFINE_CAPMIX_NOSRC(2);
2810 DEFINE_CAPMIX_NOSRC(3);
2811
2812 /*
2813  * ALC880 5-stack model
2814  *
2815  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2816  *      Side = 0x02 (0xd)
2817  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2818  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2819  */
2820
2821 /* additional mixers to alc880_three_stack_mixer */
2822 static const struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2823         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2824         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2825         { } /* end */
2826 };
2827
2828 /* channel source setting (6/8 channel selection for 5-stack) */
2829 /* 6ch mode */
2830 static const struct hda_verb alc880_fivestack_ch6_init[] = {
2831         /* set line-in to input, mute it */
2832         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2833         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2834         { } /* end */
2835 };
2836
2837 /* 8ch mode */
2838 static const struct hda_verb alc880_fivestack_ch8_init[] = {
2839         /* set line-in to output, unmute it */
2840         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2841         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2842         { } /* end */
2843 };
2844
2845 static const struct hda_channel_mode alc880_fivestack_modes[2] = {
2846         { 6, alc880_fivestack_ch6_init },
2847         { 8, alc880_fivestack_ch8_init },
2848 };
2849
2850
2851 /*
2852  * ALC880 6-stack model
2853  *
2854  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2855  *      Side = 0x05 (0x0f)
2856  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2857  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2858  */
2859
2860 static const hda_nid_t alc880_6st_dac_nids[4] = {
2861         /* front, rear, clfe, rear_surr */
2862         0x02, 0x03, 0x04, 0x05
2863 };
2864
2865 static const struct hda_input_mux alc880_6stack_capture_source = {
2866         .num_items = 4,
2867         .items = {
2868                 { "Mic", 0x0 },
2869                 { "Front Mic", 0x1 },
2870                 { "Line", 0x2 },
2871                 { "CD", 0x4 },
2872         },
2873 };
2874
2875 /* fixed 8-channels */
2876 static const struct hda_channel_mode alc880_sixstack_modes[1] = {
2877         { 8, NULL },
2878 };
2879
2880 static const struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2881         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2882         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2883         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2884         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2885         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2886         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2887         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2888         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2889         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2890         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2891         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2892         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2893         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2894         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2895         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2896         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2897         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2898         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2899         {
2900                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2901                 .name = "Channel Mode",
2902                 .info = alc_ch_mode_info,
2903                 .get = alc_ch_mode_get,
2904                 .put = alc_ch_mode_put,
2905         },
2906         { } /* end */
2907 };
2908
2909
2910 /*
2911  * ALC880 W810 model
2912  *
2913  * W810 has rear IO for:
2914  * Front (DAC 02)
2915  * Surround (DAC 03)
2916  * Center/LFE (DAC 04)
2917  * Digital out (06)
2918  *
2919  * The system also has a pair of internal speakers, and a headphone jack.
2920  * These are both connected to Line2 on the codec, hence to DAC 02.
2921  *
2922  * There is a variable resistor to control the speaker or headphone
2923  * volume. This is a hardware-only device without a software API.
2924  *
2925  * Plugging headphones in will disable the internal speakers. This is
2926  * implemented in hardware, not via the driver using jack sense. In
2927  * a similar fashion, plugging into the rear socket marked "front" will
2928  * disable both the speakers and headphones.
2929  *
2930  * For input, there's a microphone jack, and an "audio in" jack.
2931  * These may not do anything useful with this driver yet, because I
2932  * haven't setup any initialization verbs for these yet...
2933  */
2934
2935 static const hda_nid_t alc880_w810_dac_nids[3] = {
2936         /* front, rear/surround, clfe */
2937         0x02, 0x03, 0x04
2938 };
2939
2940 /* fixed 6 channels */
2941 static const struct hda_channel_mode alc880_w810_modes[1] = {
2942         { 6, NULL }
2943 };
2944
2945 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2946 static const struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2947         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2948         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2949         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2950         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2951         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2952         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2953         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2954         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2955         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2956         { } /* end */
2957 };
2958
2959
2960 /*
2961  * Z710V model
2962  *
2963  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2964  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2965  *                 Line = 0x1a
2966  */
2967
2968 static const hda_nid_t alc880_z71v_dac_nids[1] = {
2969         0x02
2970 };
2971 #define ALC880_Z71V_HP_DAC      0x03
2972
2973 /* fixed 2 channels */
2974 static const struct hda_channel_mode alc880_2_jack_modes[1] = {
2975         { 2, NULL }
2976 };
2977
2978 static const struct snd_kcontrol_new alc880_z71v_mixer[] = {
2979         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2980         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2981         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2982         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2983         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2984         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2985         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2986         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2987         { } /* end */
2988 };
2989
2990
2991 /*
2992  * ALC880 F1734 model
2993  *
2994  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2995  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2996  */
2997
2998 static const hda_nid_t alc880_f1734_dac_nids[1] = {
2999         0x03
3000 };
3001 #define ALC880_F1734_HP_DAC     0x02
3002
3003 static const struct snd_kcontrol_new alc880_f1734_mixer[] = {
3004         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3005         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
3006         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3007         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
3008         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
3009         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
3010         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3011         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3012         { } /* end */
3013 };
3014
3015 static const struct hda_input_mux alc880_f1734_capture_source = {
3016         .num_items = 2,
3017         .items = {
3018                 { "Mic", 0x1 },
3019                 { "CD", 0x4 },
3020         },
3021 };
3022
3023
3024 /*
3025  * ALC880 ASUS model
3026  *
3027  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
3028  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
3029  *  Mic = 0x18, Line = 0x1a
3030  */
3031
3032 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
3033 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
3034
3035 static const struct snd_kcontrol_new alc880_asus_mixer[] = {
3036         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3037         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3038         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3039         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3040         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3041         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3042         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3043         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3044         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
3045         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
3046         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3047         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3048         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3049         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3050         {
3051                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3052                 .name = "Channel Mode",
3053                 .info = alc_ch_mode_info,
3054                 .get = alc_ch_mode_get,
3055                 .put = alc_ch_mode_put,
3056         },
3057         { } /* end */
3058 };
3059
3060 /*
3061  * ALC880 ASUS W1V model
3062  *
3063  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
3064  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
3065  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
3066  */
3067
3068 /* additional mixers to alc880_asus_mixer */
3069 static const struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
3070         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
3071         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
3072         { } /* end */
3073 };
3074
3075 /* TCL S700 */
3076 static const struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
3077         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3078         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
3079         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
3080         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
3081         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
3082         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
3083         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
3084         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
3085         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
3086         { } /* end */
3087 };
3088
3089 /* Uniwill */
3090 static const struct snd_kcontrol_new alc880_uniwill_mixer[] = {
3091         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3092         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
3093         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3094         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
3095         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3096         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3097         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3098         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3099         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
3100         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
3101         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3102         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3103         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3104         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3105         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3106         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3107         {
3108                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3109                 .name = "Channel Mode",
3110                 .info = alc_ch_mode_info,
3111                 .get = alc_ch_mode_get,
3112                 .put = alc_ch_mode_put,
3113         },
3114         { } /* end */
3115 };
3116
3117 static const struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
3118         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3119         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
3120         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3121         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
3122         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
3123         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
3124         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3125         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3126         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3127         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3128         { } /* end */
3129 };
3130
3131 static const struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
3132         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3133         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
3134         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3135         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
3136         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3137         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3138         { } /* end */
3139 };
3140
3141 /*
3142  * virtual master controls
3143  */
3144
3145 /*
3146  * slave controls for virtual master
3147  */
3148 static const char * const alc_slave_vols[] = {
3149         "Front Playback Volume",
3150         "Surround Playback Volume",
3151         "Center Playback Volume",
3152         "LFE Playback Volume",
3153         "Side Playback Volume",
3154         "Headphone Playback Volume",
3155         "Speaker Playback Volume",
3156         "Mono Playback Volume",
3157         "Line-Out Playback Volume",
3158         NULL,
3159 };
3160
3161 static const char * const alc_slave_sws[] = {
3162         "Front Playback Switch",
3163         "Surround Playback Switch",
3164         "Center Playback Switch",
3165         "LFE Playback Switch",
3166         "Side Playback Switch",
3167         "Headphone Playback Switch",
3168         "Speaker Playback Switch",
3169         "Mono Playback Switch",
3170         "IEC958 Playback Switch",
3171         "Line-Out Playback Switch",
3172         NULL,
3173 };
3174
3175 /*
3176  * build control elements
3177  */
3178
3179 #define NID_MAPPING             (-1)
3180
3181 #define SUBDEV_SPEAKER_         (0 << 6)
3182 #define SUBDEV_HP_              (1 << 6)
3183 #define SUBDEV_LINE_            (2 << 6)
3184 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
3185 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
3186 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
3187
3188 static void alc_free_kctls(struct hda_codec *codec);
3189
3190 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3191 /* additional beep mixers; the actual parameters are overwritten at build */
3192 static const struct snd_kcontrol_new alc_beep_mixer[] = {
3193         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
3194         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
3195         { } /* end */
3196 };
3197 #endif
3198
3199 static int alc_build_controls(struct hda_codec *codec)
3200 {
3201         struct alc_spec *spec = codec->spec;
3202         struct snd_kcontrol *kctl = NULL;
3203         const struct snd_kcontrol_new *knew;
3204         int i, j, err;
3205         unsigned int u;
3206         hda_nid_t nid;
3207
3208         for (i = 0; i < spec->num_mixers; i++) {
3209                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
3210                 if (err < 0)
3211                         return err;
3212         }
3213         if (spec->cap_mixer) {
3214                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
3215                 if (err < 0)
3216                         return err;
3217         }
3218         if (spec->multiout.dig_out_nid) {
3219                 err = snd_hda_create_spdif_out_ctls(codec,
3220                                                     spec->multiout.dig_out_nid);
3221                 if (err < 0)
3222                         return err;
3223                 if (!spec->no_analog) {
3224                         err = snd_hda_create_spdif_share_sw(codec,
3225                                                             &spec->multiout);
3226                         if (err < 0)
3227                                 return err;
3228                         spec->multiout.share_spdif = 1;
3229                 }
3230         }
3231         if (spec->dig_in_nid) {
3232                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
3233                 if (err < 0)
3234                         return err;
3235         }
3236
3237 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3238         /* create beep controls if needed */
3239         if (spec->beep_amp) {
3240                 const struct snd_kcontrol_new *knew;
3241                 for (knew = alc_beep_mixer; knew->name; knew++) {
3242                         struct snd_kcontrol *kctl;
3243                         kctl = snd_ctl_new1(knew, codec);
3244                         if (!kctl)
3245                                 return -ENOMEM;
3246                         kctl->private_value = spec->beep_amp;
3247                         err = snd_hda_ctl_add(codec, 0, kctl);
3248                         if (err < 0)
3249                                 return err;
3250                 }
3251         }
3252 #endif
3253
3254         /* if we have no master control, let's create it */
3255         if (!spec->no_analog &&
3256             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
3257                 unsigned int vmaster_tlv[4];
3258                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
3259                                         HDA_OUTPUT, vmaster_tlv);
3260                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
3261                                           vmaster_tlv, alc_slave_vols);
3262                 if (err < 0)
3263                         return err;
3264         }
3265         if (!spec->no_analog &&
3266             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
3267                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
3268                                           NULL, alc_slave_sws);
3269                 if (err < 0)
3270                         return err;
3271         }
3272
3273         /* assign Capture Source enums to NID */
3274         if (spec->capsrc_nids || spec->adc_nids) {
3275                 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
3276                 if (!kctl)
3277                         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
3278                 for (i = 0; kctl && i < kctl->count; i++) {
3279                         const hda_nid_t *nids = spec->capsrc_nids;
3280                         if (!nids)
3281                                 nids = spec->adc_nids;
3282                         err = snd_hda_add_nid(codec, kctl, i, nids[i]);
3283                         if (err < 0)
3284                                 return err;
3285                 }
3286         }
3287         if (spec->cap_mixer) {
3288                 const char *kname = kctl ? kctl->id.name : NULL;
3289                 for (knew = spec->cap_mixer; knew->name; knew++) {
3290                         if (kname && strcmp(knew->name, kname) == 0)
3291                                 continue;
3292                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3293                         for (i = 0; kctl && i < kctl->count; i++) {
3294                                 err = snd_hda_add_nid(codec, kctl, i,
3295                                                       spec->adc_nids[i]);
3296                                 if (err < 0)
3297                                         return err;
3298                         }
3299                 }
3300         }
3301
3302         /* other nid->control mapping */
3303         for (i = 0; i < spec->num_mixers; i++) {
3304                 for (knew = spec->mixers[i]; knew->name; knew++) {
3305                         if (knew->iface != NID_MAPPING)
3306                                 continue;
3307                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3308                         if (kctl == NULL)
3309                                 continue;
3310                         u = knew->subdevice;
3311                         for (j = 0; j < 4; j++, u >>= 8) {
3312                                 nid = u & 0x3f;
3313                                 if (nid == 0)
3314                                         continue;
3315                                 switch (u & 0xc0) {
3316                                 case SUBDEV_SPEAKER_:
3317                                         nid = spec->autocfg.speaker_pins[nid];
3318                                         break;
3319                                 case SUBDEV_LINE_:
3320                                         nid = spec->autocfg.line_out_pins[nid];
3321                                         break;
3322                                 case SUBDEV_HP_:
3323                                         nid = spec->autocfg.hp_pins[nid];
3324                                         break;
3325                                 default:
3326                                         continue;
3327                                 }
3328                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
3329                                 if (err < 0)
3330                                         return err;
3331                         }
3332                         u = knew->private_value;
3333                         for (j = 0; j < 4; j++, u >>= 8) {
3334                                 nid = u & 0xff;
3335                                 if (nid == 0)
3336                                         continue;
3337                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
3338                                 if (err < 0)
3339                                         return err;
3340                         }
3341                 }
3342         }
3343
3344         alc_free_kctls(codec); /* no longer needed */
3345
3346         return 0;
3347 }
3348
3349
3350 /*
3351  * initialize the codec volumes, etc
3352  */
3353
3354 /*
3355  * generic initialization of ADC, input mixers and output mixers
3356  */
3357 static const struct hda_verb alc880_volume_init_verbs[] = {
3358         /*
3359          * Unmute ADC0-2 and set the default input to mic-in
3360          */
3361         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3362         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3363         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3364         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3365         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3366         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3367
3368         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3369          * mixer widget
3370          * Note: PASD motherboards uses the Line In 2 as the input for front
3371          * panel mic (mic 2)
3372          */
3373         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
3374         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3375         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3376         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3377         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3378         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3379         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3380         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3381
3382         /*
3383          * Set up output mixers (0x0c - 0x0f)
3384          */
3385         /* set vol=0 to output mixers */
3386         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3387         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3388         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3389         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3390         /* set up input amps for analog loopback */
3391         /* Amp Indices: DAC = 0, mixer = 1 */
3392         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3393         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3394         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3395         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3396         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3397         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3398         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3399         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3400
3401         { }
3402 };
3403
3404 /*
3405  * 3-stack pin configuration:
3406  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
3407  */
3408 static const struct hda_verb alc880_pin_3stack_init_verbs[] = {
3409         /*
3410          * preset connection lists of input pins
3411          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3412          */
3413         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3414         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3415         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3416
3417         /*
3418          * Set pin mode and muting
3419          */
3420         /* set front pin widgets 0x14 for output */
3421         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3422         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3423         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3424         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3425         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3426         /* Mic2 (as headphone out) for HP output */
3427         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3428         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3429         /* Line In pin widget for input */
3430         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3431         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3432         /* Line2 (as front mic) pin widget for input and vref at 80% */
3433         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3434         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3435         /* CD pin widget for input */
3436         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3437
3438         { }
3439 };
3440
3441 /*
3442  * 5-stack pin configuration:
3443  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
3444  * line-in/side = 0x1a, f-mic = 0x1b
3445  */
3446 static const struct hda_verb alc880_pin_5stack_init_verbs[] = {
3447         /*
3448          * preset connection lists of input pins
3449          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3450          */
3451         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3452         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
3453
3454         /*
3455          * Set pin mode and muting
3456          */
3457         /* set pin widgets 0x14-0x17 for output */
3458         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3459         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3460         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3461         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3462         /* unmute pins for output (no gain on this amp) */
3463         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3464         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3465         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3466         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3467
3468         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3469         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3470         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3471         /* Mic2 (as headphone out) for HP output */
3472         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3473         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3474         /* Line In pin widget for input */
3475         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3476         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3477         /* Line2 (as front mic) pin widget for input and vref at 80% */
3478         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3479         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3480         /* CD pin widget for input */
3481         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3482
3483         { }
3484 };
3485
3486 /*
3487  * W810 pin configuration:
3488  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
3489  */
3490 static const struct hda_verb alc880_pin_w810_init_verbs[] = {
3491         /* hphone/speaker input selector: front DAC */
3492         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
3493
3494         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3495         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3496         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3497         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3498         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3499         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3500
3501         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3502         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3503
3504         { }
3505 };
3506
3507 /*
3508  * Z71V pin configuration:
3509  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
3510  */
3511 static const struct hda_verb alc880_pin_z71v_init_verbs[] = {
3512         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3513         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3514         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3515         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3516
3517         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3518         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3519         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3520         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3521
3522         { }
3523 };
3524
3525 /*
3526  * 6-stack pin configuration:
3527  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
3528  * f-mic = 0x19, line = 0x1a, HP = 0x1b
3529  */
3530 static const struct hda_verb alc880_pin_6stack_init_verbs[] = {
3531         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3532
3533         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3534         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3535         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3536         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3537         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3538         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3539         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3540         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3541
3542         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3543         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3544         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3545         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3546         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3547         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3548         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3549         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3550         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3551
3552         { }
3553 };
3554
3555 /*
3556  * Uniwill pin configuration:
3557  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
3558  * line = 0x1a
3559  */
3560 static const struct hda_verb alc880_uniwill_init_verbs[] = {
3561         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3562
3563         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3564         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3565         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3566         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3567         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3568         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3569         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3570         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3571         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3572         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3573         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3574         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3575         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3576         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3577
3578         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3579         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3580         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3581         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3582         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3583         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3584         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
3585         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
3586         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3587
3588         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3589         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
3590
3591         { }
3592 };
3593
3594 /*
3595 * Uniwill P53
3596 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
3597  */
3598 static const struct hda_verb alc880_uniwill_p53_init_verbs[] = {
3599         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3600
3601         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3602         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3603         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3604         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3605         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3606         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3607         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3608         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3609         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3610         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3611         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3612         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3613
3614         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3615         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3616         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3617         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3618         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3619         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3620
3621         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3622         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
3623
3624         { }
3625 };
3626
3627 static const struct hda_verb alc880_beep_init_verbs[] = {
3628         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
3629         { }
3630 };
3631
3632 /* auto-toggle front mic */
3633 static void alc88x_simple_mic_automute(struct hda_codec *codec)
3634 {
3635         unsigned int present;
3636         unsigned char bits;
3637
3638         present = snd_hda_jack_detect(codec, 0x18);
3639         bits = present ? HDA_AMP_MUTE : 0;
3640         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
3641 }
3642
3643 static void alc880_uniwill_setup(struct hda_codec *codec)
3644 {
3645         struct alc_spec *spec = codec->spec;
3646
3647         spec->autocfg.hp_pins[0] = 0x14;
3648         spec->autocfg.speaker_pins[0] = 0x15;
3649         spec->autocfg.speaker_pins[0] = 0x16;
3650         spec->automute = 1;
3651         spec->automute_mode = ALC_AUTOMUTE_AMP;
3652 }
3653
3654 static void alc880_uniwill_init_hook(struct hda_codec *codec)
3655 {
3656         alc_hp_automute(codec);
3657         alc88x_simple_mic_automute(codec);
3658 }
3659
3660 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
3661                                        unsigned int res)
3662 {
3663         /* Looks like the unsol event is incompatible with the standard
3664          * definition.  4bit tag is placed at 28 bit!
3665          */
3666         switch (res >> 28) {
3667         case ALC880_MIC_EVENT:
3668                 alc88x_simple_mic_automute(codec);
3669                 break;
3670         default:
3671                 alc_sku_unsol_event(codec, res);
3672                 break;
3673         }
3674 }
3675
3676 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
3677 {
3678         struct alc_spec *spec = codec->spec;
3679
3680         spec->autocfg.hp_pins[0] = 0x14;
3681         spec->autocfg.speaker_pins[0] = 0x15;
3682         spec->automute = 1;
3683         spec->automute_mode = ALC_AUTOMUTE_AMP;
3684 }
3685
3686 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
3687 {
3688         unsigned int present;
3689
3690         present = snd_hda_codec_read(codec, 0x21, 0,
3691                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
3692         present &= HDA_AMP_VOLMASK;
3693         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
3694                                  HDA_AMP_VOLMASK, present);
3695         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
3696                                  HDA_AMP_VOLMASK, present);
3697 }
3698
3699 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
3700                                            unsigned int res)
3701 {
3702         /* Looks like the unsol event is incompatible with the standard
3703          * definition.  4bit tag is placed at 28 bit!
3704          */
3705         if ((res >> 28) == ALC880_DCVOL_EVENT)
3706                 alc880_uniwill_p53_dcvol_automute(codec);
3707         else
3708                 alc_sku_unsol_event(codec, res);
3709 }
3710
3711 /*
3712  * F1734 pin configuration:
3713  * HP = 0x14, speaker-out = 0x15, mic = 0x18
3714  */
3715 static const struct hda_verb alc880_pin_f1734_init_verbs[] = {
3716         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
3717         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3718         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3719         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3720         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3721
3722         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3723         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3724         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3725         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3726
3727         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3728         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3729         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3730         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3731         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3732         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3733         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3734         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3735         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3736
3737         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3738         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3739
3740         { }
3741 };
3742
3743 /*
3744  * ASUS pin configuration:
3745  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3746  */
3747 static const struct hda_verb alc880_pin_asus_init_verbs[] = {
3748         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3749         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3750         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3751         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3752
3753         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3754         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3755         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3756         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3757         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3758         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3759         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3760         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3761
3762         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3763         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3764         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3765         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3766         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3767         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3768         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3769         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3770         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3771
3772         { }
3773 };
3774
3775 /* Enable GPIO mask and set output */
3776 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
3777 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
3778 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
3779
3780 /* Clevo m520g init */
3781 static const struct hda_verb alc880_pin_clevo_init_verbs[] = {
3782         /* headphone output */
3783         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3784         /* line-out */
3785         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3786         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3787         /* Line-in */
3788         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3789         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3790         /* CD */
3791         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3792         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3793         /* Mic1 (rear panel) */
3794         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3795         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3796         /* Mic2 (front panel) */
3797         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3798         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3799         /* headphone */
3800         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3801         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3802         /* change to EAPD mode */
3803         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3804         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3805
3806         { }
3807 };
3808
3809 static const struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3810         /* change to EAPD mode */
3811         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3812         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3813
3814         /* Headphone output */
3815         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3816         /* Front output*/
3817         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3818         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3819
3820         /* Line In pin widget for input */
3821         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3822         /* CD pin widget for input */
3823         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3824         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3825         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3826
3827         /* change to EAPD mode */
3828         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3829         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3830
3831         { }
3832 };
3833
3834 /*
3835  * LG m1 express dual
3836  *
3837  * Pin assignment:
3838  *   Rear Line-In/Out (blue): 0x14
3839  *   Build-in Mic-In: 0x15
3840  *   Speaker-out: 0x17
3841  *   HP-Out (green): 0x1b
3842  *   Mic-In/Out (red): 0x19
3843  *   SPDIF-Out: 0x1e
3844  */
3845
3846 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3847 static const hda_nid_t alc880_lg_dac_nids[3] = {
3848         0x05, 0x02, 0x03
3849 };
3850
3851 /* seems analog CD is not working */
3852 static const struct hda_input_mux alc880_lg_capture_source = {
3853         .num_items = 3,
3854         .items = {
3855                 { "Mic", 0x1 },
3856                 { "Line", 0x5 },
3857                 { "Internal Mic", 0x6 },
3858         },
3859 };
3860
3861 /* 2,4,6 channel modes */
3862 static const struct hda_verb alc880_lg_ch2_init[] = {
3863         /* set line-in and mic-in to input */
3864         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3865         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3866         { }
3867 };
3868
3869 static const struct hda_verb alc880_lg_ch4_init[] = {
3870         /* set line-in to out and mic-in to input */
3871         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3872         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3873         { }
3874 };
3875
3876 static const struct hda_verb alc880_lg_ch6_init[] = {
3877         /* set line-in and mic-in to output */
3878         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3879         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3880         { }
3881 };
3882
3883 static const struct hda_channel_mode alc880_lg_ch_modes[3] = {
3884         { 2, alc880_lg_ch2_init },
3885         { 4, alc880_lg_ch4_init },
3886         { 6, alc880_lg_ch6_init },
3887 };
3888
3889 static const struct snd_kcontrol_new alc880_lg_mixer[] = {
3890         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3891         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3892         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3893         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3894         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3895         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3896         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3897         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3898         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3899         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3900         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3901         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3902         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3903         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3904         {
3905                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3906                 .name = "Channel Mode",
3907                 .info = alc_ch_mode_info,
3908                 .get = alc_ch_mode_get,
3909                 .put = alc_ch_mode_put,
3910         },
3911         { } /* end */
3912 };
3913
3914 static const struct hda_verb alc880_lg_init_verbs[] = {
3915         /* set capture source to mic-in */
3916         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3917         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3918         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3919         /* mute all amp mixer inputs */
3920         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3921         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3922         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3923         /* line-in to input */
3924         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3925         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3926         /* built-in mic */
3927         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3928         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3929         /* speaker-out */
3930         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3931         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3932         /* mic-in to input */
3933         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3934         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3935         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3936         /* HP-out */
3937         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3938         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3939         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3940         /* jack sense */
3941         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3942         { }
3943 };
3944
3945 /* toggle speaker-output according to the hp-jack state */
3946 static void alc880_lg_setup(struct hda_codec *codec)
3947 {
3948         struct alc_spec *spec = codec->spec;
3949
3950         spec->autocfg.hp_pins[0] = 0x1b;
3951         spec->autocfg.speaker_pins[0] = 0x17;
3952         spec->automute = 1;
3953         spec->automute_mode = ALC_AUTOMUTE_AMP;
3954 }
3955
3956 /*
3957  * LG LW20
3958  *
3959  * Pin assignment:
3960  *   Speaker-out: 0x14
3961  *   Mic-In: 0x18
3962  *   Built-in Mic-In: 0x19
3963  *   Line-In: 0x1b
3964  *   HP-Out: 0x1a
3965  *   SPDIF-Out: 0x1e
3966  */
3967
3968 static const struct hda_input_mux alc880_lg_lw_capture_source = {
3969         .num_items = 3,
3970         .items = {
3971                 { "Mic", 0x0 },
3972                 { "Internal Mic", 0x1 },
3973                 { "Line In", 0x2 },
3974         },
3975 };
3976
3977 #define alc880_lg_lw_modes alc880_threestack_modes
3978
3979 static const struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3980         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3981         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3982         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3983         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3984         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3985         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3986         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3987         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3988         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3989         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3990         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3991         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3992         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3993         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3994         {
3995                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3996                 .name = "Channel Mode",
3997                 .info = alc_ch_mode_info,
3998                 .get = alc_ch_mode_get,
3999                 .put = alc_ch_mode_put,
4000         },
4001         { } /* end */
4002 };
4003
4004 static const struct hda_verb alc880_lg_lw_init_verbs[] = {
4005         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
4006         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
4007         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
4008
4009         /* set capture source to mic-in */
4010         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4011         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4012         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4013         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
4014         /* speaker-out */
4015         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4016         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4017         /* HP-out */
4018         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4019         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4020         /* mic-in to input */
4021         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4022         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4023         /* built-in mic */
4024         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4025         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4026         /* jack sense */
4027         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4028         { }
4029 };
4030
4031 /* toggle speaker-output according to the hp-jack state */
4032 static void alc880_lg_lw_setup(struct hda_codec *codec)
4033 {
4034         struct alc_spec *spec = codec->spec;
4035
4036         spec->autocfg.hp_pins[0] = 0x1b;
4037         spec->autocfg.speaker_pins[0] = 0x14;
4038         spec->automute = 1;
4039         spec->automute_mode = ALC_AUTOMUTE_AMP;
4040 }
4041
4042 static const struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
4043         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4044         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
4045         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
4046         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
4047         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
4048         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
4049         { } /* end */
4050 };
4051
4052 static const struct hda_input_mux alc880_medion_rim_capture_source = {
4053         .num_items = 2,
4054         .items = {
4055                 { "Mic", 0x0 },
4056                 { "Internal Mic", 0x1 },
4057         },
4058 };
4059
4060 static const struct hda_verb alc880_medion_rim_init_verbs[] = {
4061         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
4062
4063         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4064         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4065
4066         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4067         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4068         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4069         /* Mic2 (as headphone out) for HP output */
4070         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4071         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4072         /* Internal Speaker */
4073         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4074         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4075
4076         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
4077         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
4078
4079         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4080         { }
4081 };
4082
4083 /* toggle speaker-output according to the hp-jack state */
4084 static void alc880_medion_rim_automute(struct hda_codec *codec)
4085 {
4086         struct alc_spec *spec = codec->spec;
4087         alc_hp_automute(codec);
4088         /* toggle EAPD */
4089         if (spec->jack_present)
4090                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
4091         else
4092                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
4093 }
4094
4095 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
4096                                           unsigned int res)
4097 {
4098         /* Looks like the unsol event is incompatible with the standard
4099          * definition.  4bit tag is placed at 28 bit!
4100          */
4101         if ((res >> 28) == ALC880_HP_EVENT)
4102                 alc880_medion_rim_automute(codec);
4103 }
4104
4105 static void alc880_medion_rim_setup(struct hda_codec *codec)
4106 {
4107         struct alc_spec *spec = codec->spec;
4108
4109         spec->autocfg.hp_pins[0] = 0x14;
4110         spec->autocfg.speaker_pins[0] = 0x1b;
4111         spec->automute = 1;
4112         spec->automute_mode = ALC_AUTOMUTE_AMP;
4113 }
4114
4115 #ifdef CONFIG_SND_HDA_POWER_SAVE
4116 static const struct hda_amp_list alc880_loopbacks[] = {
4117         { 0x0b, HDA_INPUT, 0 },
4118         { 0x0b, HDA_INPUT, 1 },
4119         { 0x0b, HDA_INPUT, 2 },
4120         { 0x0b, HDA_INPUT, 3 },
4121         { 0x0b, HDA_INPUT, 4 },
4122         { } /* end */
4123 };
4124
4125 static const struct hda_amp_list alc880_lg_loopbacks[] = {
4126         { 0x0b, HDA_INPUT, 1 },
4127         { 0x0b, HDA_INPUT, 6 },
4128         { 0x0b, HDA_INPUT, 7 },
4129         { } /* end */
4130 };
4131 #endif
4132
4133 /*
4134  * Common callbacks
4135  */
4136
4137 static void alc_init_special_input_src(struct hda_codec *codec);
4138
4139 static int alc_init(struct hda_codec *codec)
4140 {
4141         struct alc_spec *spec = codec->spec;
4142         unsigned int i;
4143
4144         alc_fix_pll(codec);
4145         alc_auto_init_amp(codec, spec->init_amp);
4146
4147         for (i = 0; i < spec->num_init_verbs; i++)
4148                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
4149         alc_init_special_input_src(codec);
4150
4151         if (spec->init_hook)
4152                 spec->init_hook(codec);
4153
4154         alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
4155
4156         hda_call_check_power_status(codec, 0x01);
4157         return 0;
4158 }
4159
4160 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
4161 {
4162         struct alc_spec *spec = codec->spec;
4163
4164         if (spec->unsol_event)
4165                 spec->unsol_event(codec, res);
4166 }
4167
4168 #ifdef CONFIG_SND_HDA_POWER_SAVE
4169 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
4170 {
4171         struct alc_spec *spec = codec->spec;
4172         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
4173 }
4174 #endif
4175
4176 /*
4177  * Analog playback callbacks
4178  */
4179 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
4180                                     struct hda_codec *codec,
4181                                     struct snd_pcm_substream *substream)
4182 {
4183         struct alc_spec *spec = codec->spec;
4184         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
4185                                              hinfo);
4186 }
4187
4188 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4189                                        struct hda_codec *codec,
4190                                        unsigned int stream_tag,
4191                                        unsigned int format,
4192                                        struct snd_pcm_substream *substream)
4193 {
4194         struct alc_spec *spec = codec->spec;
4195         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
4196                                                 stream_tag, format, substream);
4197 }
4198
4199 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4200                                        struct hda_codec *codec,
4201                                        struct snd_pcm_substream *substream)
4202 {
4203         struct alc_spec *spec = codec->spec;
4204         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
4205 }
4206
4207 /*
4208  * Digital out
4209  */
4210 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
4211                                         struct hda_codec *codec,
4212                                         struct snd_pcm_substream *substream)
4213 {
4214         struct alc_spec *spec = codec->spec;
4215         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
4216 }
4217
4218 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4219                                            struct hda_codec *codec,
4220                                            unsigned int stream_tag,
4221                                            unsigned int format,
4222                                            struct snd_pcm_substream *substream)
4223 {
4224         struct alc_spec *spec = codec->spec;
4225         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
4226                                              stream_tag, format, substream);
4227 }
4228
4229 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4230                                            struct hda_codec *codec,
4231                                            struct snd_pcm_substream *substream)
4232 {
4233         struct alc_spec *spec = codec->spec;
4234         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
4235 }
4236
4237 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
4238                                          struct hda_codec *codec,
4239                                          struct snd_pcm_substream *substream)
4240 {
4241         struct alc_spec *spec = codec->spec;
4242         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
4243 }
4244
4245 /*
4246  * Analog capture
4247  */
4248 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4249                                       struct hda_codec *codec,
4250                                       unsigned int stream_tag,
4251                                       unsigned int format,
4252                                       struct snd_pcm_substream *substream)
4253 {
4254         struct alc_spec *spec = codec->spec;
4255
4256         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
4257                                    stream_tag, 0, format);
4258         return 0;
4259 }
4260
4261 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4262                                       struct hda_codec *codec,
4263                                       struct snd_pcm_substream *substream)
4264 {
4265         struct alc_spec *spec = codec->spec;
4266
4267         snd_hda_codec_cleanup_stream(codec,
4268                                      spec->adc_nids[substream->number + 1]);
4269         return 0;
4270 }
4271
4272 /* analog capture with dynamic dual-adc changes */
4273 static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4274                                        struct hda_codec *codec,
4275                                        unsigned int stream_tag,
4276                                        unsigned int format,
4277                                        struct snd_pcm_substream *substream)
4278 {
4279         struct alc_spec *spec = codec->spec;
4280         spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
4281         spec->cur_adc_stream_tag = stream_tag;
4282         spec->cur_adc_format = format;
4283         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
4284         return 0;
4285 }
4286
4287 static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4288                                        struct hda_codec *codec,
4289                                        struct snd_pcm_substream *substream)
4290 {
4291         struct alc_spec *spec = codec->spec;
4292         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
4293         spec->cur_adc = 0;
4294         return 0;
4295 }
4296
4297 static const struct hda_pcm_stream dualmic_pcm_analog_capture = {
4298         .substreams = 1,
4299         .channels_min = 2,
4300         .channels_max = 2,
4301         .nid = 0, /* fill later */
4302         .ops = {
4303                 .prepare = dualmic_capture_pcm_prepare,
4304                 .cleanup = dualmic_capture_pcm_cleanup
4305         },
4306 };
4307
4308 /*
4309  */
4310 static const struct hda_pcm_stream alc880_pcm_analog_playback = {
4311         .substreams = 1,
4312         .channels_min = 2,
4313         .channels_max = 8,
4314         /* NID is set in alc_build_pcms */
4315         .ops = {
4316                 .open = alc880_playback_pcm_open,
4317                 .prepare = alc880_playback_pcm_prepare,
4318                 .cleanup = alc880_playback_pcm_cleanup
4319         },
4320 };
4321
4322 static const struct hda_pcm_stream alc880_pcm_analog_capture = {
4323         .substreams = 1,
4324         .channels_min = 2,
4325         .channels_max = 2,
4326         /* NID is set in alc_build_pcms */
4327 };
4328
4329 static const struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
4330         .substreams = 1,
4331         .channels_min = 2,
4332         .channels_max = 2,
4333         /* NID is set in alc_build_pcms */
4334 };
4335
4336 static const struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
4337         .substreams = 2, /* can be overridden */
4338         .channels_min = 2,
4339         .channels_max = 2,
4340         /* NID is set in alc_build_pcms */
4341         .ops = {
4342                 .prepare = alc880_alt_capture_pcm_prepare,
4343                 .cleanup = alc880_alt_capture_pcm_cleanup
4344         },
4345 };
4346
4347 static const struct hda_pcm_stream alc880_pcm_digital_playback = {
4348         .substreams = 1,
4349         .channels_min = 2,
4350         .channels_max = 2,
4351         /* NID is set in alc_build_pcms */
4352         .ops = {
4353                 .open = alc880_dig_playback_pcm_open,
4354                 .close = alc880_dig_playback_pcm_close,
4355                 .prepare = alc880_dig_playback_pcm_prepare,
4356                 .cleanup = alc880_dig_playback_pcm_cleanup
4357         },
4358 };
4359
4360 static const struct hda_pcm_stream alc880_pcm_digital_capture = {
4361         .substreams = 1,
4362         .channels_min = 2,
4363         .channels_max = 2,
4364         /* NID is set in alc_build_pcms */
4365 };
4366
4367 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
4368 static const struct hda_pcm_stream alc_pcm_null_stream = {
4369         .substreams = 0,
4370         .channels_min = 0,
4371         .channels_max = 0,
4372 };
4373
4374 static int alc_build_pcms(struct hda_codec *codec)
4375 {
4376         struct alc_spec *spec = codec->spec;
4377         struct hda_pcm *info = spec->pcm_rec;
4378         int i;
4379
4380         codec->num_pcms = 1;
4381         codec->pcm_info = info;
4382
4383         if (spec->no_analog)
4384                 goto skip_analog;
4385
4386         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
4387                  "%s Analog", codec->chip_name);
4388         info->name = spec->stream_name_analog;
4389
4390         if (spec->stream_analog_playback) {
4391                 if (snd_BUG_ON(!spec->multiout.dac_nids))
4392                         return -EINVAL;
4393                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
4394                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4395         }
4396         if (spec->stream_analog_capture) {
4397                 if (snd_BUG_ON(!spec->adc_nids))
4398                         return -EINVAL;
4399                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
4400                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4401         }
4402
4403         if (spec->channel_mode) {
4404                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
4405                 for (i = 0; i < spec->num_channel_mode; i++) {
4406                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
4407                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
4408                         }
4409                 }
4410         }
4411
4412  skip_analog:
4413         /* SPDIF for stream index #1 */
4414         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4415                 snprintf(spec->stream_name_digital,
4416                          sizeof(spec->stream_name_digital),
4417                          "%s Digital", codec->chip_name);
4418                 codec->num_pcms = 2;
4419                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4420                 info = spec->pcm_rec + 1;
4421                 info->name = spec->stream_name_digital;
4422                 if (spec->dig_out_type)
4423                         info->pcm_type = spec->dig_out_type;
4424                 else
4425                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
4426                 if (spec->multiout.dig_out_nid &&
4427                     spec->stream_digital_playback) {
4428                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
4429                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4430                 }
4431                 if (spec->dig_in_nid &&
4432                     spec->stream_digital_capture) {
4433                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
4434                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4435                 }
4436                 /* FIXME: do we need this for all Realtek codec models? */
4437                 codec->spdif_status_reset = 1;
4438         }
4439
4440         if (spec->no_analog)
4441                 return 0;
4442
4443         /* If the use of more than one ADC is requested for the current
4444          * model, configure a second analog capture-only PCM.
4445          */
4446         /* Additional Analaog capture for index #2 */
4447         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
4448             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
4449                 codec->num_pcms = 3;
4450                 info = spec->pcm_rec + 2;
4451                 info->name = spec->stream_name_analog;
4452                 if (spec->alt_dac_nid) {
4453                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4454                                 *spec->stream_analog_alt_playback;
4455                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4456                                 spec->alt_dac_nid;
4457                 } else {
4458                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4459                                 alc_pcm_null_stream;
4460                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4461                 }
4462                 if (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture) {
4463                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4464                                 *spec->stream_analog_alt_capture;
4465                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4466                                 spec->adc_nids[1];
4467                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4468                                 spec->num_adc_nids - 1;
4469                 } else {
4470                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4471                                 alc_pcm_null_stream;
4472                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4473                 }
4474         }
4475
4476         return 0;
4477 }
4478
4479 static inline void alc_shutup(struct hda_codec *codec)
4480 {
4481         struct alc_spec *spec = codec->spec;
4482
4483         if (spec && spec->shutup)
4484                 spec->shutup(codec);
4485         snd_hda_shutup_pins(codec);
4486 }
4487
4488 static void alc_free_kctls(struct hda_codec *codec)
4489 {
4490         struct alc_spec *spec = codec->spec;
4491
4492         if (spec->kctls.list) {
4493                 struct snd_kcontrol_new *kctl = spec->kctls.list;
4494                 int i;
4495                 for (i = 0; i < spec->kctls.used; i++)
4496                         kfree(kctl[i].name);
4497         }
4498         snd_array_free(&spec->kctls);
4499 }
4500
4501 static void alc_free(struct hda_codec *codec)
4502 {
4503         struct alc_spec *spec = codec->spec;
4504
4505         if (!spec)
4506                 return;
4507
4508         alc_shutup(codec);
4509         snd_hda_input_jack_free(codec);
4510         alc_free_kctls(codec);
4511         kfree(spec);
4512         snd_hda_detach_beep_device(codec);
4513 }
4514
4515 #ifdef CONFIG_SND_HDA_POWER_SAVE
4516 static void alc_power_eapd(struct hda_codec *codec)
4517 {
4518         alc_auto_setup_eapd(codec, false);
4519 }
4520
4521 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
4522 {
4523         struct alc_spec *spec = codec->spec;
4524         alc_shutup(codec);
4525         if (spec && spec->power_hook)
4526                 spec->power_hook(codec);
4527         return 0;
4528 }
4529 #endif
4530
4531 #ifdef SND_HDA_NEEDS_RESUME
4532 static int alc_resume(struct hda_codec *codec)
4533 {
4534         msleep(150); /* to avoid pop noise */
4535         codec->patch_ops.init(codec);
4536         snd_hda_codec_resume_amp(codec);
4537         snd_hda_codec_resume_cache(codec);
4538         hda_call_check_power_status(codec, 0x01);
4539         return 0;
4540 }
4541 #endif
4542
4543 /*
4544  */
4545 static const struct hda_codec_ops alc_patch_ops = {
4546         .build_controls = alc_build_controls,
4547         .build_pcms = alc_build_pcms,
4548         .init = alc_init,
4549         .free = alc_free,
4550         .unsol_event = alc_unsol_event,
4551 #ifdef SND_HDA_NEEDS_RESUME
4552         .resume = alc_resume,
4553 #endif
4554 #ifdef CONFIG_SND_HDA_POWER_SAVE
4555         .suspend = alc_suspend,
4556         .check_power_status = alc_check_power_status,
4557 #endif
4558         .reboot_notify = alc_shutup,
4559 };
4560
4561 /* replace the codec chip_name with the given string */
4562 static int alc_codec_rename(struct hda_codec *codec, const char *name)
4563 {
4564         kfree(codec->chip_name);
4565         codec->chip_name = kstrdup(name, GFP_KERNEL);
4566         if (!codec->chip_name) {
4567                 alc_free(codec);
4568                 return -ENOMEM;
4569         }
4570         return 0;
4571 }
4572
4573 /*
4574  * Test configuration for debugging
4575  *
4576  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
4577  * enum controls.
4578  */
4579 #ifdef CONFIG_SND_DEBUG
4580 static const hda_nid_t alc880_test_dac_nids[4] = {
4581         0x02, 0x03, 0x04, 0x05
4582 };
4583
4584 static const struct hda_input_mux alc880_test_capture_source = {
4585         .num_items = 7,
4586         .items = {
4587                 { "In-1", 0x0 },
4588                 { "In-2", 0x1 },
4589                 { "In-3", 0x2 },
4590                 { "In-4", 0x3 },
4591                 { "CD", 0x4 },
4592                 { "Front", 0x5 },
4593                 { "Surround", 0x6 },
4594         },
4595 };
4596
4597 static const struct hda_channel_mode alc880_test_modes[4] = {
4598         { 2, NULL },
4599         { 4, NULL },
4600         { 6, NULL },
4601         { 8, NULL },
4602 };
4603
4604 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
4605                                  struct snd_ctl_elem_info *uinfo)
4606 {
4607         static const char * const texts[] = {
4608                 "N/A", "Line Out", "HP Out",
4609                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
4610         };
4611         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4612         uinfo->count = 1;
4613         uinfo->value.enumerated.items = 8;
4614         if (uinfo->value.enumerated.item >= 8)
4615                 uinfo->value.enumerated.item = 7;
4616         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4617         return 0;
4618 }
4619
4620 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
4621                                 struct snd_ctl_elem_value *ucontrol)
4622 {
4623         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4624         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4625         unsigned int pin_ctl, item = 0;
4626
4627         pin_ctl = snd_hda_codec_read(codec, nid, 0,
4628                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4629         if (pin_ctl & AC_PINCTL_OUT_EN) {
4630                 if (pin_ctl & AC_PINCTL_HP_EN)
4631                         item = 2;
4632                 else
4633                         item = 1;
4634         } else if (pin_ctl & AC_PINCTL_IN_EN) {
4635                 switch (pin_ctl & AC_PINCTL_VREFEN) {
4636                 case AC_PINCTL_VREF_HIZ: item = 3; break;
4637                 case AC_PINCTL_VREF_50:  item = 4; break;
4638                 case AC_PINCTL_VREF_GRD: item = 5; break;
4639                 case AC_PINCTL_VREF_80:  item = 6; break;
4640                 case AC_PINCTL_VREF_100: item = 7; break;
4641                 }
4642         }
4643         ucontrol->value.enumerated.item[0] = item;
4644         return 0;
4645 }
4646
4647 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
4648                                 struct snd_ctl_elem_value *ucontrol)
4649 {
4650         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4651         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4652         static const unsigned int ctls[] = {
4653                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
4654                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
4655                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
4656                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
4657                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
4658                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
4659         };
4660         unsigned int old_ctl, new_ctl;
4661
4662         old_ctl = snd_hda_codec_read(codec, nid, 0,
4663                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4664         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
4665         if (old_ctl != new_ctl) {
4666                 int val;
4667                 snd_hda_codec_write_cache(codec, nid, 0,
4668                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4669                                           new_ctl);
4670                 val = ucontrol->value.enumerated.item[0] >= 3 ?
4671                         HDA_AMP_MUTE : 0;
4672                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
4673                                          HDA_AMP_MUTE, val);
4674                 return 1;
4675         }
4676         return 0;
4677 }
4678
4679 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
4680                                  struct snd_ctl_elem_info *uinfo)
4681 {
4682         static const char * const texts[] = {
4683                 "Front", "Surround", "CLFE", "Side"
4684         };
4685         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4686         uinfo->count = 1;
4687         uinfo->value.enumerated.items = 4;
4688         if (uinfo->value.enumerated.item >= 4)
4689                 uinfo->value.enumerated.item = 3;
4690         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4691         return 0;
4692 }
4693
4694 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
4695                                 struct snd_ctl_elem_value *ucontrol)
4696 {
4697         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4698         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4699         unsigned int sel;
4700
4701         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
4702         ucontrol->value.enumerated.item[0] = sel & 3;
4703         return 0;
4704 }
4705
4706 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
4707                                 struct snd_ctl_elem_value *ucontrol)
4708 {
4709         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4710         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4711         unsigned int sel;
4712
4713         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
4714         if (ucontrol->value.enumerated.item[0] != sel) {
4715                 sel = ucontrol->value.enumerated.item[0] & 3;
4716                 snd_hda_codec_write_cache(codec, nid, 0,
4717                                           AC_VERB_SET_CONNECT_SEL, sel);
4718                 return 1;
4719         }
4720         return 0;
4721 }
4722
4723 #define PIN_CTL_TEST(xname,nid) {                       \
4724                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4725                         .name = xname,                 \
4726                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4727                         .info = alc_test_pin_ctl_info, \
4728                         .get = alc_test_pin_ctl_get,   \
4729                         .put = alc_test_pin_ctl_put,   \
4730                         .private_value = nid           \
4731                         }
4732
4733 #define PIN_SRC_TEST(xname,nid) {                       \
4734                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4735                         .name = xname,                 \
4736                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4737                         .info = alc_test_pin_src_info, \
4738                         .get = alc_test_pin_src_get,   \
4739                         .put = alc_test_pin_src_put,   \
4740                         .private_value = nid           \
4741                         }
4742
4743 static const struct snd_kcontrol_new alc880_test_mixer[] = {
4744         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4745         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4746         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
4747         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4748         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4749         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4750         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
4751         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4752         PIN_CTL_TEST("Front Pin Mode", 0x14),
4753         PIN_CTL_TEST("Surround Pin Mode", 0x15),
4754         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
4755         PIN_CTL_TEST("Side Pin Mode", 0x17),
4756         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
4757         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
4758         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
4759         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
4760         PIN_SRC_TEST("In-1 Pin Source", 0x18),
4761         PIN_SRC_TEST("In-2 Pin Source", 0x19),
4762         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
4763         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
4764         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
4765         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
4766         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
4767         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
4768         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
4769         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
4770         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
4771         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
4772         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
4773         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
4774         {
4775                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4776                 .name = "Channel Mode",
4777                 .info = alc_ch_mode_info,
4778                 .get = alc_ch_mode_get,
4779                 .put = alc_ch_mode_put,
4780         },
4781         { } /* end */
4782 };
4783
4784 static const struct hda_verb alc880_test_init_verbs[] = {
4785         /* Unmute inputs of 0x0c - 0x0f */
4786         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4787         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4788         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4789         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4790         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4791         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4792         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4793         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4794         /* Vol output for 0x0c-0x0f */
4795         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4796         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4797         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4798         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4799         /* Set output pins 0x14-0x17 */
4800         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4801         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4802         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4803         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4804         /* Unmute output pins 0x14-0x17 */
4805         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4806         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4807         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4808         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4809         /* Set input pins 0x18-0x1c */
4810         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4811         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4812         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4813         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4814         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4815         /* Mute input pins 0x18-0x1b */
4816         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4817         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4818         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4819         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4820         /* ADC set up */
4821         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4822         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4823         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4824         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4825         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4826         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4827         /* Analog input/passthru */
4828         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4829         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4830         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4831         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4832         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4833         { }
4834 };
4835 #endif
4836
4837 /*
4838  */
4839
4840 static const char * const alc880_models[ALC880_MODEL_LAST] = {
4841         [ALC880_3ST]            = "3stack",
4842         [ALC880_TCL_S700]       = "tcl",
4843         [ALC880_3ST_DIG]        = "3stack-digout",
4844         [ALC880_CLEVO]          = "clevo",
4845         [ALC880_5ST]            = "5stack",
4846         [ALC880_5ST_DIG]        = "5stack-digout",
4847         [ALC880_W810]           = "w810",
4848         [ALC880_Z71V]           = "z71v",
4849         [ALC880_6ST]            = "6stack",
4850         [ALC880_6ST_DIG]        = "6stack-digout",
4851         [ALC880_ASUS]           = "asus",
4852         [ALC880_ASUS_W1V]       = "asus-w1v",
4853         [ALC880_ASUS_DIG]       = "asus-dig",
4854         [ALC880_ASUS_DIG2]      = "asus-dig2",
4855         [ALC880_UNIWILL_DIG]    = "uniwill",
4856         [ALC880_UNIWILL_P53]    = "uniwill-p53",
4857         [ALC880_FUJITSU]        = "fujitsu",
4858         [ALC880_F1734]          = "F1734",
4859         [ALC880_LG]             = "lg",
4860         [ALC880_LG_LW]          = "lg-lw",
4861         [ALC880_MEDION_RIM]     = "medion",
4862 #ifdef CONFIG_SND_DEBUG
4863         [ALC880_TEST]           = "test",
4864 #endif
4865         [ALC880_AUTO]           = "auto",
4866 };
4867
4868 static const struct snd_pci_quirk alc880_cfg_tbl[] = {
4869         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4870         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4871         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4872         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4873         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4874         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4875         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4876         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4877         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4878         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4879         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4880         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4881         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4882         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4883         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4884         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4885         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4886         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4887         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4888         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4889         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4890         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4891         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4892         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4893         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4894         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4895         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4896         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4897         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4898         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4899         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4900         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4901         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4902         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4903         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4904         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4905         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4906         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4907         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4908         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4909         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_F1734),
4910         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4911         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4912         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4913         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4914         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4915         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4916         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4917         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4918         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
4919         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4920         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4921         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4922         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_LG),
4923         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4924         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4925         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4926         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4927         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4928         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4929         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4930         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4931         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4932         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4933         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4934         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4935         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4936         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4937         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4938         /* default Intel */
4939         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4940         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4941         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4942         {}
4943 };
4944
4945 /*
4946  * ALC880 codec presets
4947  */
4948 static const struct alc_config_preset alc880_presets[] = {
4949         [ALC880_3ST] = {
4950                 .mixers = { alc880_three_stack_mixer },
4951                 .init_verbs = { alc880_volume_init_verbs,
4952                                 alc880_pin_3stack_init_verbs },
4953                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4954                 .dac_nids = alc880_dac_nids,
4955                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4956                 .channel_mode = alc880_threestack_modes,
4957                 .need_dac_fix = 1,
4958                 .input_mux = &alc880_capture_source,
4959         },
4960         [ALC880_3ST_DIG] = {
4961                 .mixers = { alc880_three_stack_mixer },
4962                 .init_verbs = { alc880_volume_init_verbs,
4963                                 alc880_pin_3stack_init_verbs },
4964                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4965                 .dac_nids = alc880_dac_nids,
4966                 .dig_out_nid = ALC880_DIGOUT_NID,
4967                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4968                 .channel_mode = alc880_threestack_modes,
4969                 .need_dac_fix = 1,
4970                 .input_mux = &alc880_capture_source,
4971         },
4972         [ALC880_TCL_S700] = {
4973                 .mixers = { alc880_tcl_s700_mixer },
4974                 .init_verbs = { alc880_volume_init_verbs,
4975                                 alc880_pin_tcl_S700_init_verbs,
4976                                 alc880_gpio2_init_verbs },
4977                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4978                 .dac_nids = alc880_dac_nids,
4979                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4980                 .num_adc_nids = 1, /* single ADC */
4981                 .hp_nid = 0x03,
4982                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4983                 .channel_mode = alc880_2_jack_modes,
4984                 .input_mux = &alc880_capture_source,
4985         },
4986         [ALC880_5ST] = {
4987                 .mixers = { alc880_three_stack_mixer,
4988                             alc880_five_stack_mixer},
4989                 .init_verbs = { alc880_volume_init_verbs,
4990                                 alc880_pin_5stack_init_verbs },
4991                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4992                 .dac_nids = alc880_dac_nids,
4993                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4994                 .channel_mode = alc880_fivestack_modes,
4995                 .input_mux = &alc880_capture_source,
4996         },
4997         [ALC880_5ST_DIG] = {
4998                 .mixers = { alc880_three_stack_mixer,
4999                             alc880_five_stack_mixer },
5000                 .init_verbs = { alc880_volume_init_verbs,
5001                                 alc880_pin_5stack_init_verbs },
5002                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5003                 .dac_nids = alc880_dac_nids,
5004                 .dig_out_nid = ALC880_DIGOUT_NID,
5005                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
5006                 .channel_mode = alc880_fivestack_modes,
5007                 .input_mux = &alc880_capture_source,
5008         },
5009         [ALC880_6ST] = {
5010                 .mixers = { alc880_six_stack_mixer },
5011                 .init_verbs = { alc880_volume_init_verbs,
5012                                 alc880_pin_6stack_init_verbs },
5013                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
5014                 .dac_nids = alc880_6st_dac_nids,
5015                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
5016                 .channel_mode = alc880_sixstack_modes,
5017                 .input_mux = &alc880_6stack_capture_source,
5018         },
5019         [ALC880_6ST_DIG] = {
5020                 .mixers = { alc880_six_stack_mixer },
5021                 .init_verbs = { alc880_volume_init_verbs,
5022                                 alc880_pin_6stack_init_verbs },
5023                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
5024                 .dac_nids = alc880_6st_dac_nids,
5025                 .dig_out_nid = ALC880_DIGOUT_NID,
5026                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
5027                 .channel_mode = alc880_sixstack_modes,
5028                 .input_mux = &alc880_6stack_capture_source,
5029         },
5030         [ALC880_W810] = {
5031                 .mixers = { alc880_w810_base_mixer },
5032                 .init_verbs = { alc880_volume_init_verbs,
5033                                 alc880_pin_w810_init_verbs,
5034                                 alc880_gpio2_init_verbs },
5035                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
5036                 .dac_nids = alc880_w810_dac_nids,
5037                 .dig_out_nid = ALC880_DIGOUT_NID,
5038                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
5039                 .channel_mode = alc880_w810_modes,
5040                 .input_mux = &alc880_capture_source,
5041         },
5042         [ALC880_Z71V] = {
5043                 .mixers = { alc880_z71v_mixer },
5044                 .init_verbs = { alc880_volume_init_verbs,
5045                                 alc880_pin_z71v_init_verbs },
5046                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
5047                 .dac_nids = alc880_z71v_dac_nids,
5048                 .dig_out_nid = ALC880_DIGOUT_NID,
5049                 .hp_nid = 0x03,
5050                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
5051                 .channel_mode = alc880_2_jack_modes,
5052                 .input_mux = &alc880_capture_source,
5053         },
5054         [ALC880_F1734] = {
5055                 .mixers = { alc880_f1734_mixer },
5056                 .init_verbs = { alc880_volume_init_verbs,
5057                                 alc880_pin_f1734_init_verbs },
5058                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
5059                 .dac_nids = alc880_f1734_dac_nids,
5060                 .hp_nid = 0x02,
5061                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
5062                 .channel_mode = alc880_2_jack_modes,
5063                 .input_mux = &alc880_f1734_capture_source,
5064                 .unsol_event = alc880_uniwill_p53_unsol_event,
5065                 .setup = alc880_uniwill_p53_setup,
5066                 .init_hook = alc_hp_automute,
5067         },
5068         [ALC880_ASUS] = {
5069                 .mixers = { alc880_asus_mixer },
5070                 .init_verbs = { alc880_volume_init_verbs,
5071                                 alc880_pin_asus_init_verbs,
5072                                 alc880_gpio1_init_verbs },
5073                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5074                 .dac_nids = alc880_asus_dac_nids,
5075                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5076                 .channel_mode = alc880_asus_modes,
5077                 .need_dac_fix = 1,
5078                 .input_mux = &alc880_capture_source,
5079         },
5080         [ALC880_ASUS_DIG] = {
5081                 .mixers = { alc880_asus_mixer },
5082                 .init_verbs = { alc880_volume_init_verbs,
5083                                 alc880_pin_asus_init_verbs,
5084                                 alc880_gpio1_init_verbs },
5085                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5086                 .dac_nids = alc880_asus_dac_nids,
5087                 .dig_out_nid = ALC880_DIGOUT_NID,
5088                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5089                 .channel_mode = alc880_asus_modes,
5090                 .need_dac_fix = 1,
5091                 .input_mux = &alc880_capture_source,
5092         },
5093         [ALC880_ASUS_DIG2] = {
5094                 .mixers = { alc880_asus_mixer },
5095                 .init_verbs = { alc880_volume_init_verbs,
5096                                 alc880_pin_asus_init_verbs,
5097                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
5098                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5099                 .dac_nids = alc880_asus_dac_nids,
5100                 .dig_out_nid = ALC880_DIGOUT_NID,
5101                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5102                 .channel_mode = alc880_asus_modes,
5103                 .need_dac_fix = 1,
5104                 .input_mux = &alc880_capture_source,
5105         },
5106         [ALC880_ASUS_W1V] = {
5107                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
5108                 .init_verbs = { alc880_volume_init_verbs,
5109                                 alc880_pin_asus_init_verbs,
5110                                 alc880_gpio1_init_verbs },
5111                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5112                 .dac_nids = alc880_asus_dac_nids,
5113                 .dig_out_nid = ALC880_DIGOUT_NID,
5114                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5115                 .channel_mode = alc880_asus_modes,
5116                 .need_dac_fix = 1,
5117                 .input_mux = &alc880_capture_source,
5118         },
5119         [ALC880_UNIWILL_DIG] = {
5120                 .mixers = { alc880_asus_mixer },
5121                 .init_verbs = { alc880_volume_init_verbs,
5122                                 alc880_pin_asus_init_verbs },
5123                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5124                 .dac_nids = alc880_asus_dac_nids,
5125                 .dig_out_nid = ALC880_DIGOUT_NID,
5126                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5127                 .channel_mode = alc880_asus_modes,
5128                 .need_dac_fix = 1,
5129                 .input_mux = &alc880_capture_source,
5130         },
5131         [ALC880_UNIWILL] = {
5132                 .mixers = { alc880_uniwill_mixer },
5133                 .init_verbs = { alc880_volume_init_verbs,
5134                                 alc880_uniwill_init_verbs },
5135                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5136                 .dac_nids = alc880_asus_dac_nids,
5137                 .dig_out_nid = ALC880_DIGOUT_NID,
5138                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
5139                 .channel_mode = alc880_threestack_modes,
5140                 .need_dac_fix = 1,
5141                 .input_mux = &alc880_capture_source,
5142                 .unsol_event = alc880_uniwill_unsol_event,
5143                 .setup = alc880_uniwill_setup,
5144                 .init_hook = alc880_uniwill_init_hook,
5145         },
5146         [ALC880_UNIWILL_P53] = {
5147                 .mixers = { alc880_uniwill_p53_mixer },
5148                 .init_verbs = { alc880_volume_init_verbs,
5149                                 alc880_uniwill_p53_init_verbs },
5150                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5151                 .dac_nids = alc880_asus_dac_nids,
5152                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
5153                 .channel_mode = alc880_threestack_modes,
5154                 .input_mux = &alc880_capture_source,
5155                 .unsol_event = alc880_uniwill_p53_unsol_event,
5156                 .setup = alc880_uniwill_p53_setup,
5157                 .init_hook = alc_hp_automute,
5158         },
5159         [ALC880_FUJITSU] = {
5160                 .mixers = { alc880_fujitsu_mixer },
5161                 .init_verbs = { alc880_volume_init_verbs,
5162                                 alc880_uniwill_p53_init_verbs,
5163                                 alc880_beep_init_verbs },
5164                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5165                 .dac_nids = alc880_dac_nids,
5166                 .dig_out_nid = ALC880_DIGOUT_NID,
5167                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
5168                 .channel_mode = alc880_2_jack_modes,
5169                 .input_mux = &alc880_capture_source,
5170                 .unsol_event = alc880_uniwill_p53_unsol_event,
5171                 .setup = alc880_uniwill_p53_setup,
5172                 .init_hook = alc_hp_automute,
5173         },
5174         [ALC880_CLEVO] = {
5175                 .mixers = { alc880_three_stack_mixer },
5176                 .init_verbs = { alc880_volume_init_verbs,
5177                                 alc880_pin_clevo_init_verbs },
5178                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5179                 .dac_nids = alc880_dac_nids,
5180                 .hp_nid = 0x03,
5181                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
5182                 .channel_mode = alc880_threestack_modes,
5183                 .need_dac_fix = 1,
5184                 .input_mux = &alc880_capture_source,
5185         },
5186         [ALC880_LG] = {
5187                 .mixers = { alc880_lg_mixer },
5188                 .init_verbs = { alc880_volume_init_verbs,
5189                                 alc880_lg_init_verbs },
5190                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
5191                 .dac_nids = alc880_lg_dac_nids,
5192                 .dig_out_nid = ALC880_DIGOUT_NID,
5193                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
5194                 .channel_mode = alc880_lg_ch_modes,
5195                 .need_dac_fix = 1,
5196                 .input_mux = &alc880_lg_capture_source,
5197                 .unsol_event = alc_sku_unsol_event,
5198                 .setup = alc880_lg_setup,
5199                 .init_hook = alc_hp_automute,
5200 #ifdef CONFIG_SND_HDA_POWER_SAVE
5201                 .loopbacks = alc880_lg_loopbacks,
5202 #endif
5203         },
5204         [ALC880_LG_LW] = {
5205                 .mixers = { alc880_lg_lw_mixer },
5206                 .init_verbs = { alc880_volume_init_verbs,
5207                                 alc880_lg_lw_init_verbs },
5208                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5209                 .dac_nids = alc880_dac_nids,
5210                 .dig_out_nid = ALC880_DIGOUT_NID,
5211                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
5212                 .channel_mode = alc880_lg_lw_modes,
5213                 .input_mux = &alc880_lg_lw_capture_source,
5214                 .unsol_event = alc_sku_unsol_event,
5215                 .setup = alc880_lg_lw_setup,
5216                 .init_hook = alc_hp_automute,
5217         },
5218         [ALC880_MEDION_RIM] = {
5219                 .mixers = { alc880_medion_rim_mixer },
5220                 .init_verbs = { alc880_volume_init_verbs,
5221                                 alc880_medion_rim_init_verbs,
5222                                 alc_gpio2_init_verbs },
5223                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5224                 .dac_nids = alc880_dac_nids,
5225                 .dig_out_nid = ALC880_DIGOUT_NID,
5226                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
5227                 .channel_mode = alc880_2_jack_modes,
5228                 .input_mux = &alc880_medion_rim_capture_source,
5229                 .unsol_event = alc880_medion_rim_unsol_event,
5230                 .setup = alc880_medion_rim_setup,
5231                 .init_hook = alc880_medion_rim_automute,
5232         },
5233 #ifdef CONFIG_SND_DEBUG
5234         [ALC880_TEST] = {
5235                 .mixers = { alc880_test_mixer },
5236                 .init_verbs = { alc880_test_init_verbs },
5237                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
5238                 .dac_nids = alc880_test_dac_nids,
5239                 .dig_out_nid = ALC880_DIGOUT_NID,
5240                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
5241                 .channel_mode = alc880_test_modes,
5242                 .input_mux = &alc880_test_capture_source,
5243         },
5244 #endif
5245 };
5246
5247 /*
5248  * Automatic parse of I/O pins from the BIOS configuration
5249  */
5250
5251 enum {
5252         ALC_CTL_WIDGET_VOL,
5253         ALC_CTL_WIDGET_MUTE,
5254         ALC_CTL_BIND_MUTE,
5255 };
5256 static const struct snd_kcontrol_new alc880_control_templates[] = {
5257         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
5258         HDA_CODEC_MUTE(NULL, 0, 0, 0),
5259         HDA_BIND_MUTE(NULL, 0, 0, 0),
5260 };
5261
5262 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
5263 {
5264         snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
5265         return snd_array_new(&spec->kctls);
5266 }
5267
5268 /* add dynamic controls */
5269 static int add_control(struct alc_spec *spec, int type, const char *name,
5270                        int cidx, unsigned long val)
5271 {
5272         struct snd_kcontrol_new *knew;
5273
5274         knew = alc_kcontrol_new(spec);
5275         if (!knew)
5276                 return -ENOMEM;
5277         *knew = alc880_control_templates[type];
5278         knew->name = kstrdup(name, GFP_KERNEL);
5279         if (!knew->name)
5280                 return -ENOMEM;
5281         knew->index = cidx;
5282         if (get_amp_nid_(val))
5283                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
5284         knew->private_value = val;
5285         return 0;
5286 }
5287
5288 static int add_control_with_pfx(struct alc_spec *spec, int type,
5289                                 const char *pfx, const char *dir,
5290                                 const char *sfx, int cidx, unsigned long val)
5291 {
5292         char name[32];
5293         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
5294         return add_control(spec, type, name, cidx, val);
5295 }
5296
5297 #define add_pb_vol_ctrl(spec, type, pfx, val)                   \
5298         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
5299 #define add_pb_sw_ctrl(spec, type, pfx, val)                    \
5300         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
5301 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)                   \
5302         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
5303 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)                    \
5304         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
5305
5306 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
5307 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
5308 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
5309 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
5310 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
5311 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
5312 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
5313 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
5314 #define ALC880_PIN_CD_NID               0x1c
5315
5316 /* fill in the dac_nids table from the parsed pin configuration */
5317 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
5318                                      const struct auto_pin_cfg *cfg)
5319 {
5320         hda_nid_t nid;
5321         int assigned[4];
5322         int i, j;
5323
5324         memset(assigned, 0, sizeof(assigned));
5325         spec->multiout.dac_nids = spec->private_dac_nids;
5326
5327         /* check the pins hardwired to audio widget */
5328         for (i = 0; i < cfg->line_outs; i++) {
5329                 nid = cfg->line_out_pins[i];
5330                 if (alc880_is_fixed_pin(nid)) {
5331                         int idx = alc880_fixed_pin_idx(nid);
5332                         spec->private_dac_nids[i] = alc880_idx_to_dac(idx);
5333                         assigned[idx] = 1;
5334                 }
5335         }
5336         /* left pins can be connect to any audio widget */
5337         for (i = 0; i < cfg->line_outs; i++) {
5338                 nid = cfg->line_out_pins[i];
5339                 if (alc880_is_fixed_pin(nid))
5340                         continue;
5341                 /* search for an empty channel */
5342                 for (j = 0; j < cfg->line_outs; j++) {
5343                         if (!assigned[j]) {
5344                                 spec->private_dac_nids[i] =
5345                                         alc880_idx_to_dac(j);
5346                                 assigned[j] = 1;
5347                                 break;
5348                         }
5349                 }
5350         }
5351         spec->multiout.num_dacs = cfg->line_outs;
5352         return 0;
5353 }
5354
5355 static const char *alc_get_line_out_pfx(struct alc_spec *spec,
5356                                         bool can_be_master)
5357 {
5358         struct auto_pin_cfg *cfg = &spec->autocfg;
5359
5360         if (cfg->line_outs == 1 && !spec->multi_ios &&
5361             !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
5362                 return "Master";
5363
5364         switch (cfg->line_out_type) {
5365         case AUTO_PIN_SPEAKER_OUT:
5366                 if (cfg->line_outs == 1)
5367                         return "Speaker";
5368                 break;
5369         case AUTO_PIN_HP_OUT:
5370                 return "Headphone";
5371         default:
5372                 if (cfg->line_outs == 1 && !spec->multi_ios)
5373                         return "PCM";
5374                 break;
5375         }
5376         return NULL;
5377 }
5378
5379 /* add playback controls from the parsed DAC table */
5380 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
5381                                              const struct auto_pin_cfg *cfg)
5382 {
5383         static const char * const chname[4] = {
5384                 "Front", "Surround", NULL /*CLFE*/, "Side"
5385         };
5386         const char *pfx = alc_get_line_out_pfx(spec, false);
5387         hda_nid_t nid;
5388         int i, err, noutputs;
5389
5390         noutputs = cfg->line_outs;
5391         if (spec->multi_ios > 0)
5392                 noutputs += spec->multi_ios;
5393
5394         for (i = 0; i < noutputs; i++) {
5395                 if (!spec->multiout.dac_nids[i])
5396                         continue;
5397                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
5398                 if (!pfx && i == 2) {
5399                         /* Center/LFE */
5400                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5401                                               "Center",
5402                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
5403                                                               HDA_OUTPUT));
5404                         if (err < 0)
5405                                 return err;
5406                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5407                                               "LFE",
5408                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
5409                                                               HDA_OUTPUT));
5410                         if (err < 0)
5411                                 return err;
5412                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5413                                              "Center",
5414                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
5415                                                               HDA_INPUT));
5416                         if (err < 0)
5417                                 return err;
5418                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5419                                              "LFE",
5420                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
5421                                                               HDA_INPUT));
5422                         if (err < 0)
5423                                 return err;
5424                 } else {
5425                         const char *name = pfx;
5426                         int index = i;
5427                         if (!name) {
5428                                 name = chname[i];
5429                                 index = 0;
5430                         }
5431                         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5432                                                 name, index,
5433                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
5434                                                               HDA_OUTPUT));
5435                         if (err < 0)
5436                                 return err;
5437                         err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5438                                                name, index,
5439                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
5440                                                               HDA_INPUT));
5441                         if (err < 0)
5442                                 return err;
5443                 }
5444         }
5445         return 0;
5446 }
5447
5448 /* add playback controls for speaker and HP outputs */
5449 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
5450                                         const char *pfx)
5451 {
5452         hda_nid_t nid;
5453         int err;
5454
5455         if (!pin)
5456                 return 0;
5457
5458         if (alc880_is_fixed_pin(pin)) {
5459                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
5460                 /* specify the DAC as the extra output */
5461                 if (!spec->multiout.hp_nid)
5462                         spec->multiout.hp_nid = nid;
5463                 else
5464                         spec->multiout.extra_out_nid[0] = nid;
5465                 /* control HP volume/switch on the output mixer amp */
5466                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
5467                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5468                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
5469                 if (err < 0)
5470                         return err;
5471                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5472                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
5473                 if (err < 0)
5474                         return err;
5475         } else if (alc880_is_multi_pin(pin)) {
5476                 /* set manual connection */
5477                 /* we have only a switch on HP-out PIN */
5478                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
5479                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
5480                 if (err < 0)
5481                         return err;
5482         }
5483         return 0;
5484 }
5485
5486 /* create input playback/capture controls for the given pin */
5487 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
5488                             const char *ctlname, int ctlidx,
5489                             int idx, hda_nid_t mix_nid)
5490 {
5491         int err;
5492
5493         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
5494                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5495         if (err < 0)
5496                 return err;
5497         err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
5498                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5499         if (err < 0)
5500                 return err;
5501         return 0;
5502 }
5503
5504 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
5505 {
5506         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
5507         return (pincap & AC_PINCAP_IN) != 0;
5508 }
5509
5510 /* create playback/capture controls for input pins */
5511 static int alc_auto_create_input_ctls(struct hda_codec *codec,
5512                                       const struct auto_pin_cfg *cfg,
5513                                       hda_nid_t mixer,
5514                                       hda_nid_t cap1, hda_nid_t cap2)
5515 {
5516         struct alc_spec *spec = codec->spec;
5517         struct hda_input_mux *imux = &spec->private_imux[0];
5518         int i, err, idx, type_idx = 0;
5519         const char *prev_label = NULL;
5520
5521         for (i = 0; i < cfg->num_inputs; i++) {
5522                 hda_nid_t pin;
5523                 const char *label;
5524
5525                 pin = cfg->inputs[i].pin;
5526                 if (!alc_is_input_pin(codec, pin))
5527                         continue;
5528
5529                 label = hda_get_autocfg_input_label(codec, cfg, i);
5530                 if (prev_label && !strcmp(label, prev_label))
5531                         type_idx++;
5532                 else
5533                         type_idx = 0;
5534                 prev_label = label;
5535
5536                 if (mixer) {
5537                         idx = get_connection_index(codec, mixer, pin);
5538                         if (idx >= 0) {
5539                                 err = new_analog_input(spec, pin,
5540                                                        label, type_idx,
5541                                                        idx, mixer);
5542                                 if (err < 0)
5543                                         return err;
5544                         }
5545                 }
5546
5547                 if (!cap1)
5548                         continue;
5549                 idx = get_connection_index(codec, cap1, pin);
5550                 if (idx < 0 && cap2)
5551                         idx = get_connection_index(codec, cap2, pin);
5552                 if (idx >= 0)
5553                         snd_hda_add_imux_item(imux, label, idx, NULL);
5554         }
5555         return 0;
5556 }
5557
5558 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
5559                                                 const struct auto_pin_cfg *cfg)
5560 {
5561         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
5562 }
5563
5564 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
5565                                unsigned int pin_type)
5566 {
5567         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5568                             pin_type);
5569         /* unmute pin */
5570         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
5571                             AMP_OUT_UNMUTE);
5572 }
5573
5574 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
5575                                               hda_nid_t nid, int pin_type,
5576                                               int dac_idx)
5577 {
5578         alc_set_pin_output(codec, nid, pin_type);
5579         /* need the manual connection? */
5580         if (alc880_is_multi_pin(nid)) {
5581                 struct alc_spec *spec = codec->spec;
5582                 int idx = alc880_multi_pin_idx(nid);
5583                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
5584                                     AC_VERB_SET_CONNECT_SEL,
5585                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
5586         }
5587 }
5588
5589 static int get_pin_type(int line_out_type)
5590 {
5591         if (line_out_type == AUTO_PIN_HP_OUT)
5592                 return PIN_HP;
5593         else
5594                 return PIN_OUT;
5595 }
5596
5597 static void alc880_auto_init_multi_out(struct hda_codec *codec)
5598 {
5599         struct alc_spec *spec = codec->spec;
5600         int i;
5601
5602         for (i = 0; i < spec->autocfg.line_outs; i++) {
5603                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
5604                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5605                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
5606         }
5607 }
5608
5609 static void alc880_auto_init_extra_out(struct hda_codec *codec)
5610 {
5611         struct alc_spec *spec = codec->spec;
5612         hda_nid_t pin;
5613
5614         pin = spec->autocfg.speaker_pins[0];
5615         if (pin) /* connect to front */
5616                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
5617         pin = spec->autocfg.hp_pins[0];
5618         if (pin) /* connect to front */
5619                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
5620 }
5621
5622 static void alc880_auto_init_analog_input(struct hda_codec *codec)
5623 {
5624         struct alc_spec *spec = codec->spec;
5625         struct auto_pin_cfg *cfg = &spec->autocfg;
5626         int i;
5627
5628         for (i = 0; i < cfg->num_inputs; i++) {
5629                 hda_nid_t nid = cfg->inputs[i].pin;
5630                 if (alc_is_input_pin(codec, nid)) {
5631                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
5632                         if (nid != ALC880_PIN_CD_NID &&
5633                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5634                                 snd_hda_codec_write(codec, nid, 0,
5635                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5636                                                     AMP_OUT_MUTE);
5637                 }
5638         }
5639 }
5640
5641 static void alc880_auto_init_input_src(struct hda_codec *codec)
5642 {
5643         struct alc_spec *spec = codec->spec;
5644         int c;
5645
5646         for (c = 0; c < spec->num_adc_nids; c++) {
5647                 unsigned int mux_idx;
5648                 const struct hda_input_mux *imux;
5649                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
5650                 imux = &spec->input_mux[mux_idx];
5651                 if (!imux->num_items && mux_idx > 0)
5652                         imux = &spec->input_mux[0];
5653                 if (imux)
5654                         snd_hda_codec_write(codec, spec->adc_nids[c], 0,
5655                                             AC_VERB_SET_CONNECT_SEL,
5656                                             imux->items[0].index);
5657         }
5658 }
5659
5660 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec);
5661
5662 /* parse the BIOS configuration and set up the alc_spec */
5663 /* return 1 if successful, 0 if the proper config is not found,
5664  * or a negative error code
5665  */
5666 static int alc880_parse_auto_config(struct hda_codec *codec)
5667 {
5668         struct alc_spec *spec = codec->spec;
5669         int err;
5670         static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
5671
5672         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5673                                            alc880_ignore);
5674         if (err < 0)
5675                 return err;
5676         if (!spec->autocfg.line_outs)
5677                 return 0; /* can't find valid BIOS pin config */
5678
5679         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
5680         if (err < 0)
5681                 return err;
5682         err = alc_auto_add_multi_channel_mode(codec);
5683         if (err < 0)
5684                 return err;
5685         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
5686         if (err < 0)
5687                 return err;
5688         err = alc880_auto_create_extra_out(spec,
5689                                            spec->autocfg.speaker_pins[0],
5690                                            "Speaker");
5691         if (err < 0)
5692                 return err;
5693         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
5694                                            "Headphone");
5695         if (err < 0)
5696                 return err;
5697         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
5698         if (err < 0)
5699                 return err;
5700
5701         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5702
5703         alc_auto_parse_digital(codec);
5704
5705         if (spec->kctls.list)
5706                 add_mixer(spec, spec->kctls.list);
5707
5708         add_verb(spec, alc880_volume_init_verbs);
5709
5710         spec->num_mux_defs = 1;
5711         spec->input_mux = &spec->private_imux[0];
5712
5713         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
5714
5715         return 1;
5716 }
5717
5718 /* additional initialization for auto-configuration model */
5719 static void alc880_auto_init(struct hda_codec *codec)
5720 {
5721         struct alc_spec *spec = codec->spec;
5722         alc880_auto_init_multi_out(codec);
5723         alc880_auto_init_extra_out(codec);
5724         alc880_auto_init_analog_input(codec);
5725         alc880_auto_init_input_src(codec);
5726         alc_auto_init_digital(codec);
5727         if (spec->unsol_event)
5728                 alc_inithook(codec);
5729 }
5730
5731 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
5732  * one of two digital mic pins, e.g. on ALC272
5733  */
5734 static void fixup_automic_adc(struct hda_codec *codec)
5735 {
5736         struct alc_spec *spec = codec->spec;
5737         int i;
5738
5739         for (i = 0; i < spec->num_adc_nids; i++) {
5740                 hda_nid_t cap = spec->capsrc_nids ?
5741                         spec->capsrc_nids[i] : spec->adc_nids[i];
5742                 int iidx, eidx;
5743
5744                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
5745                 if (iidx < 0)
5746                         continue;
5747                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
5748                 if (eidx < 0)
5749                         continue;
5750                 spec->int_mic.mux_idx = iidx;
5751                 spec->ext_mic.mux_idx = eidx;
5752                 if (spec->capsrc_nids)
5753                         spec->capsrc_nids += i;
5754                 spec->adc_nids += i;
5755                 spec->num_adc_nids = 1;
5756                 /* optional dock-mic */
5757                 eidx = get_connection_index(codec, cap, spec->dock_mic.pin);
5758                 if (eidx < 0)
5759                         spec->dock_mic.pin = 0;
5760                 else
5761                         spec->dock_mic.mux_idx = eidx;
5762                 return;
5763         }
5764         snd_printd(KERN_INFO "hda_codec: %s: "
5765                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
5766                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
5767         spec->auto_mic = 0; /* disable auto-mic to be sure */
5768 }
5769
5770 /* select or unmute the given capsrc route */
5771 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
5772                                     int idx)
5773 {
5774         if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
5775                 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
5776                                          HDA_AMP_MUTE, 0);
5777         } else {
5778                 snd_hda_codec_write_cache(codec, cap, 0,
5779                                           AC_VERB_SET_CONNECT_SEL, idx);
5780         }
5781 }
5782
5783 /* set the default connection to that pin */
5784 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
5785 {
5786         struct alc_spec *spec = codec->spec;
5787         int i;
5788
5789         if (!pin)
5790                 return 0;
5791         for (i = 0; i < spec->num_adc_nids; i++) {
5792                 hda_nid_t cap = spec->capsrc_nids ?
5793                         spec->capsrc_nids[i] : spec->adc_nids[i];
5794                 int idx;
5795
5796                 idx = get_connection_index(codec, cap, pin);
5797                 if (idx < 0)
5798                         continue;
5799                 select_or_unmute_capsrc(codec, cap, idx);
5800                 return i; /* return the found index */
5801         }
5802         return -1; /* not found */
5803 }
5804
5805 /* choose the ADC/MUX containing the input pin and initialize the setup */
5806 static void fixup_single_adc(struct hda_codec *codec)
5807 {
5808         struct alc_spec *spec = codec->spec;
5809         struct auto_pin_cfg *cfg = &spec->autocfg;
5810         int i;
5811
5812         /* search for the input pin; there must be only one */
5813         if (cfg->num_inputs != 1)
5814                 return;
5815         i = init_capsrc_for_pin(codec, cfg->inputs[0].pin);
5816         if (i >= 0) {
5817                 /* use only this ADC */
5818                 if (spec->capsrc_nids)
5819                         spec->capsrc_nids += i;
5820                 spec->adc_nids += i;
5821                 spec->num_adc_nids = 1;
5822                 spec->single_input_src = 1;
5823         }
5824 }
5825
5826 /* initialize dual adcs */
5827 static void fixup_dual_adc_switch(struct hda_codec *codec)
5828 {
5829         struct alc_spec *spec = codec->spec;
5830         init_capsrc_for_pin(codec, spec->ext_mic.pin);
5831         init_capsrc_for_pin(codec, spec->dock_mic.pin);
5832         init_capsrc_for_pin(codec, spec->int_mic.pin);
5833 }
5834
5835 /* initialize some special cases for input sources */
5836 static void alc_init_special_input_src(struct hda_codec *codec)
5837 {
5838         struct alc_spec *spec = codec->spec;
5839         if (spec->dual_adc_switch)
5840                 fixup_dual_adc_switch(codec);
5841         else if (spec->single_input_src)
5842                 init_capsrc_for_pin(codec, spec->autocfg.inputs[0].pin);
5843 }
5844
5845 static void set_capture_mixer(struct hda_codec *codec)
5846 {
5847         struct alc_spec *spec = codec->spec;
5848         static const struct snd_kcontrol_new *caps[2][3] = {
5849                 { alc_capture_mixer_nosrc1,
5850                   alc_capture_mixer_nosrc2,
5851                   alc_capture_mixer_nosrc3 },
5852                 { alc_capture_mixer1,
5853                   alc_capture_mixer2,
5854                   alc_capture_mixer3 },
5855         };
5856         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
5857                 int mux = 0;
5858                 int num_adcs = spec->num_adc_nids;
5859                 if (spec->dual_adc_switch)
5860                         num_adcs = 1;
5861                 else if (spec->auto_mic)
5862                         fixup_automic_adc(codec);
5863                 else if (spec->input_mux) {
5864                         if (spec->input_mux->num_items > 1)
5865                                 mux = 1;
5866                         else if (spec->input_mux->num_items == 1)
5867                                 fixup_single_adc(codec);
5868                 }
5869                 spec->cap_mixer = caps[mux][num_adcs - 1];
5870         }
5871 }
5872
5873 /* fill adc_nids (and capsrc_nids) containing all active input pins */
5874 static void fillup_priv_adc_nids(struct hda_codec *codec, const hda_nid_t *nids,
5875                                  int num_nids)
5876 {
5877         struct alc_spec *spec = codec->spec;
5878         struct auto_pin_cfg *cfg = &spec->autocfg;
5879         int n;
5880         hda_nid_t fallback_adc = 0, fallback_cap = 0;
5881
5882         for (n = 0; n < num_nids; n++) {
5883                 hda_nid_t adc, cap;
5884                 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5885                 int nconns, i, j;
5886
5887                 adc = nids[n];
5888                 if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5889                         continue;
5890                 cap = adc;
5891                 nconns = snd_hda_get_connections(codec, cap, conn,
5892                                                  ARRAY_SIZE(conn));
5893                 if (nconns == 1) {
5894                         cap = conn[0];
5895                         nconns = snd_hda_get_connections(codec, cap, conn,
5896                                                          ARRAY_SIZE(conn));
5897                 }
5898                 if (nconns <= 0)
5899                         continue;
5900                 if (!fallback_adc) {
5901                         fallback_adc = adc;
5902                         fallback_cap = cap;
5903                 }
5904                 for (i = 0; i < cfg->num_inputs; i++) {
5905                         hda_nid_t nid = cfg->inputs[i].pin;
5906                         for (j = 0; j < nconns; j++) {
5907                                 if (conn[j] == nid)
5908                                         break;
5909                         }
5910                         if (j >= nconns)
5911                                 break;
5912                 }
5913                 if (i >= cfg->num_inputs) {
5914                         int num_adcs = spec->num_adc_nids;
5915                         spec->private_adc_nids[num_adcs] = adc;
5916                         spec->private_capsrc_nids[num_adcs] = cap;
5917                         spec->num_adc_nids++;
5918                         spec->adc_nids = spec->private_adc_nids;
5919                         if (adc != cap)
5920                                 spec->capsrc_nids = spec->private_capsrc_nids;
5921                 }
5922         }
5923         if (!spec->num_adc_nids) {
5924                 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5925                        " using fallback 0x%x\n",
5926                        codec->chip_name, fallback_adc);
5927                 spec->private_adc_nids[0] = fallback_adc;
5928                 spec->adc_nids = spec->private_adc_nids;
5929                 if (fallback_adc != fallback_cap) {
5930                         spec->private_capsrc_nids[0] = fallback_cap;
5931                         spec->capsrc_nids = spec->private_adc_nids;
5932                 }
5933         }
5934 }
5935
5936 #ifdef CONFIG_SND_HDA_INPUT_BEEP
5937 #define set_beep_amp(spec, nid, idx, dir) \
5938         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5939
5940 static const struct snd_pci_quirk beep_white_list[] = {
5941         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
5942         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
5943         SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
5944         SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
5945         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
5946         {}
5947 };
5948
5949 static inline int has_cdefine_beep(struct hda_codec *codec)
5950 {
5951         struct alc_spec *spec = codec->spec;
5952         const struct snd_pci_quirk *q;
5953         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
5954         if (q)
5955                 return q->value;
5956         return spec->cdefine.enable_pcbeep;
5957 }
5958 #else
5959 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
5960 #define has_cdefine_beep(codec)         0
5961 #endif
5962
5963 /*
5964  * OK, here we have finally the patch for ALC880
5965  */
5966
5967 static int patch_alc880(struct hda_codec *codec)
5968 {
5969         struct alc_spec *spec;
5970         int board_config;
5971         int err;
5972
5973         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5974         if (spec == NULL)
5975                 return -ENOMEM;
5976
5977         codec->spec = spec;
5978
5979         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5980                                                   alc880_models,
5981                                                   alc880_cfg_tbl);
5982         if (board_config < 0) {
5983                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5984                        codec->chip_name);
5985                 board_config = ALC880_AUTO;
5986         }
5987
5988         if (board_config == ALC880_AUTO) {
5989                 /* automatic parse from the BIOS config */
5990                 err = alc880_parse_auto_config(codec);
5991                 if (err < 0) {
5992                         alc_free(codec);
5993                         return err;
5994                 } else if (!err) {
5995                         printk(KERN_INFO
5996                                "hda_codec: Cannot set up configuration "
5997                                "from BIOS.  Using 3-stack mode...\n");
5998                         board_config = ALC880_3ST;
5999                 }
6000         }
6001
6002         err = snd_hda_attach_beep_device(codec, 0x1);
6003         if (err < 0) {
6004                 alc_free(codec);
6005                 return err;
6006         }
6007
6008         if (board_config != ALC880_AUTO)
6009                 setup_preset(codec, &alc880_presets[board_config]);
6010
6011         spec->stream_analog_playback = &alc880_pcm_analog_playback;
6012         spec->stream_analog_capture = &alc880_pcm_analog_capture;
6013         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
6014
6015         spec->stream_digital_playback = &alc880_pcm_digital_playback;
6016         spec->stream_digital_capture = &alc880_pcm_digital_capture;
6017
6018         if (!spec->adc_nids && spec->input_mux) {
6019                 /* check whether NID 0x07 is valid */
6020                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
6021                 /* get type */
6022                 wcap = get_wcaps_type(wcap);
6023                 if (wcap != AC_WID_AUD_IN) {
6024                         spec->adc_nids = alc880_adc_nids_alt;
6025                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
6026                 } else {
6027                         spec->adc_nids = alc880_adc_nids;
6028                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
6029                 }
6030         }
6031         set_capture_mixer(codec);
6032         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6033
6034         spec->vmaster_nid = 0x0c;
6035
6036         codec->patch_ops = alc_patch_ops;
6037         if (board_config == ALC880_AUTO)
6038                 spec->init_hook = alc880_auto_init;
6039 #ifdef CONFIG_SND_HDA_POWER_SAVE
6040         if (!spec->loopback.amplist)
6041                 spec->loopback.amplist = alc880_loopbacks;
6042 #endif
6043
6044         return 0;
6045 }
6046
6047
6048 /*
6049  * ALC260 support
6050  */
6051
6052 static const hda_nid_t alc260_dac_nids[1] = {
6053         /* front */
6054         0x02,
6055 };
6056
6057 static const hda_nid_t alc260_adc_nids[1] = {
6058         /* ADC0 */
6059         0x04,
6060 };
6061
6062 static const hda_nid_t alc260_adc_nids_alt[1] = {
6063         /* ADC1 */
6064         0x05,
6065 };
6066
6067 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
6068  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
6069  */
6070 static const hda_nid_t alc260_dual_adc_nids[2] = {
6071         /* ADC0, ADC1 */
6072         0x04, 0x05
6073 };
6074
6075 #define ALC260_DIGOUT_NID       0x03
6076 #define ALC260_DIGIN_NID        0x06
6077
6078 static const struct hda_input_mux alc260_capture_source = {
6079         .num_items = 4,
6080         .items = {
6081                 { "Mic", 0x0 },
6082                 { "Front Mic", 0x1 },
6083                 { "Line", 0x2 },
6084                 { "CD", 0x4 },
6085         },
6086 };
6087
6088 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
6089  * headphone jack and the internal CD lines since these are the only pins at
6090  * which audio can appear.  For flexibility, also allow the option of
6091  * recording the mixer output on the second ADC (ADC0 doesn't have a
6092  * connection to the mixer output).
6093  */
6094 static const struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
6095         {
6096                 .num_items = 3,
6097                 .items = {
6098                         { "Mic/Line", 0x0 },
6099                         { "CD", 0x4 },
6100                         { "Headphone", 0x2 },
6101                 },
6102         },
6103         {
6104                 .num_items = 4,
6105                 .items = {
6106                         { "Mic/Line", 0x0 },
6107                         { "CD", 0x4 },
6108                         { "Headphone", 0x2 },
6109                         { "Mixer", 0x5 },
6110                 },
6111         },
6112
6113 };
6114
6115 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
6116  * the Fujitsu S702x, but jacks are marked differently.
6117  */
6118 static const struct hda_input_mux alc260_acer_capture_sources[2] = {
6119         {
6120                 .num_items = 4,
6121                 .items = {
6122                         { "Mic", 0x0 },
6123                         { "Line", 0x2 },
6124                         { "CD", 0x4 },
6125                         { "Headphone", 0x5 },
6126                 },
6127         },
6128         {
6129                 .num_items = 5,
6130                 .items = {
6131                         { "Mic", 0x0 },
6132                         { "Line", 0x2 },
6133                         { "CD", 0x4 },
6134                         { "Headphone", 0x6 },
6135                         { "Mixer", 0x5 },
6136                 },
6137         },
6138 };
6139
6140 /* Maxdata Favorit 100XS */
6141 static const struct hda_input_mux alc260_favorit100_capture_sources[2] = {
6142         {
6143                 .num_items = 2,
6144                 .items = {
6145                         { "Line/Mic", 0x0 },
6146                         { "CD", 0x4 },
6147                 },
6148         },
6149         {
6150                 .num_items = 3,
6151                 .items = {
6152                         { "Line/Mic", 0x0 },
6153                         { "CD", 0x4 },
6154                         { "Mixer", 0x5 },
6155                 },
6156         },
6157 };
6158
6159 /*
6160  * This is just place-holder, so there's something for alc_build_pcms to look
6161  * at when it calculates the maximum number of channels. ALC260 has no mixer
6162  * element which allows changing the channel mode, so the verb list is
6163  * never used.
6164  */
6165 static const struct hda_channel_mode alc260_modes[1] = {
6166         { 2, NULL },
6167 };
6168
6169
6170 /* Mixer combinations
6171  *
6172  * basic: base_output + input + pc_beep + capture
6173  * HP: base_output + input + capture_alt
6174  * HP_3013: hp_3013 + input + capture
6175  * fujitsu: fujitsu + capture
6176  * acer: acer + capture
6177  */
6178
6179 static const struct snd_kcontrol_new alc260_base_output_mixer[] = {
6180         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6181         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
6182         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6183         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
6184         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6185         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6186         { } /* end */
6187 };
6188
6189 static const struct snd_kcontrol_new alc260_input_mixer[] = {
6190         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6191         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6192         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6193         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6194         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6195         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6196         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
6197         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
6198         { } /* end */
6199 };
6200
6201 /* update HP, line and mono out pins according to the master switch */
6202 static void alc260_hp_master_update(struct hda_codec *codec)
6203 {
6204         struct alc_spec *spec = codec->spec;
6205
6206         /* change HP pins */
6207         do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
6208                     spec->autocfg.hp_pins, spec->master_mute, true);
6209         update_speakers(codec);
6210 }
6211
6212 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
6213                                    struct snd_ctl_elem_value *ucontrol)
6214 {
6215         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
6216         struct alc_spec *spec = codec->spec;
6217         *ucontrol->value.integer.value = !spec->master_mute;
6218         return 0;
6219 }
6220
6221 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
6222                                    struct snd_ctl_elem_value *ucontrol)
6223 {
6224         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
6225         struct alc_spec *spec = codec->spec;
6226         int val = !*ucontrol->value.integer.value;
6227
6228         if (val == spec->master_mute)
6229                 return 0;
6230         spec->master_mute = val;
6231         alc260_hp_master_update(codec);
6232         return 1;
6233 }
6234
6235 static const struct snd_kcontrol_new alc260_hp_output_mixer[] = {
6236         {
6237                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6238                 .name = "Master Playback Switch",
6239                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
6240                 .info = snd_ctl_boolean_mono_info,
6241                 .get = alc260_hp_master_sw_get,
6242                 .put = alc260_hp_master_sw_put,
6243         },
6244         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6245         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
6246         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6247         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
6248         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
6249                               HDA_OUTPUT),
6250         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6251         { } /* end */
6252 };
6253
6254 static const struct hda_verb alc260_hp_unsol_verbs[] = {
6255         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6256         {},
6257 };
6258
6259 static void alc260_hp_setup(struct hda_codec *codec)
6260 {
6261         struct alc_spec *spec = codec->spec;
6262
6263         spec->autocfg.hp_pins[0] = 0x0f;
6264         spec->autocfg.speaker_pins[0] = 0x10;
6265         spec->autocfg.speaker_pins[1] = 0x11;
6266         spec->automute = 1;
6267         spec->automute_mode = ALC_AUTOMUTE_PIN;
6268 }
6269
6270 static const struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
6271         {
6272                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6273                 .name = "Master Playback Switch",
6274                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
6275                 .info = snd_ctl_boolean_mono_info,
6276                 .get = alc260_hp_master_sw_get,
6277                 .put = alc260_hp_master_sw_put,
6278         },
6279         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6280         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
6281         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
6282         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
6283         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6284         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6285         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6286         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
6287         { } /* end */
6288 };
6289
6290 static void alc260_hp_3013_setup(struct hda_codec *codec)
6291 {
6292         struct alc_spec *spec = codec->spec;
6293
6294         spec->autocfg.hp_pins[0] = 0x15;
6295         spec->autocfg.speaker_pins[0] = 0x10;
6296         spec->autocfg.speaker_pins[1] = 0x11;
6297         spec->automute = 1;
6298         spec->automute_mode = ALC_AUTOMUTE_PIN;
6299 }
6300
6301 static const struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
6302         .ops = &snd_hda_bind_vol,
6303         .values = {
6304                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
6305                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
6306                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
6307                 0
6308         },
6309 };
6310
6311 static const struct hda_bind_ctls alc260_dc7600_bind_switch = {
6312         .ops = &snd_hda_bind_sw,
6313         .values = {
6314                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
6315                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
6316                 0
6317         },
6318 };
6319
6320 static const struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
6321         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
6322         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
6323         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
6324         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
6325         { } /* end */
6326 };
6327
6328 static const struct hda_verb alc260_hp_3013_unsol_verbs[] = {
6329         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6330         {},
6331 };
6332
6333 static void alc260_hp_3012_setup(struct hda_codec *codec)
6334 {
6335         struct alc_spec *spec = codec->spec;
6336
6337         spec->autocfg.hp_pins[0] = 0x10;
6338         spec->autocfg.speaker_pins[0] = 0x0f;
6339         spec->autocfg.speaker_pins[1] = 0x11;
6340         spec->autocfg.speaker_pins[2] = 0x15;
6341         spec->automute = 1;
6342         spec->automute_mode = ALC_AUTOMUTE_PIN;
6343 }
6344
6345 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
6346  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
6347  */
6348 static const struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
6349         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6350         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
6351         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6352         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6353         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6354         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
6355         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
6356         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
6357         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6358         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
6359         { } /* end */
6360 };
6361
6362 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
6363  * versions of the ALC260 don't act on requests to enable mic bias from NID
6364  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
6365  * datasheet doesn't mention this restriction.  At this stage it's not clear
6366  * whether this behaviour is intentional or is a hardware bug in chip
6367  * revisions available in early 2006.  Therefore for now allow the
6368  * "Headphone Jack Mode" control to span all choices, but if it turns out
6369  * that the lack of mic bias for this NID is intentional we could change the
6370  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6371  *
6372  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
6373  * don't appear to make the mic bias available from the "line" jack, even
6374  * though the NID used for this jack (0x14) can supply it.  The theory is
6375  * that perhaps Acer have included blocking capacitors between the ALC260
6376  * and the output jack.  If this turns out to be the case for all such
6377  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
6378  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
6379  *
6380  * The C20x Tablet series have a mono internal speaker which is controlled
6381  * via the chip's Mono sum widget and pin complex, so include the necessary
6382  * controls for such models.  On models without a "mono speaker" the control
6383  * won't do anything.
6384  */
6385 static const struct snd_kcontrol_new alc260_acer_mixer[] = {
6386         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6387         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6388         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6389         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
6390                               HDA_OUTPUT),
6391         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
6392                            HDA_INPUT),
6393         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6394         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6395         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6396         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6397         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6398         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6399         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6400         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6401         { } /* end */
6402 };
6403
6404 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
6405  */
6406 static const struct snd_kcontrol_new alc260_favorit100_mixer[] = {
6407         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6408         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6409         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6410         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6411         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6412         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6413         { } /* end */
6414 };
6415
6416 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
6417  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
6418  */
6419 static const struct snd_kcontrol_new alc260_will_mixer[] = {
6420         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6421         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6422         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6423         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6424         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6425         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6426         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6427         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6428         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6429         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6430         { } /* end */
6431 };
6432
6433 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
6434  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
6435  */
6436 static const struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
6437         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6438         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6439         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6440         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6441         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6442         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
6443         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
6444         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6445         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6446         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6447         { } /* end */
6448 };
6449
6450 /*
6451  * initialization verbs
6452  */
6453 static const struct hda_verb alc260_init_verbs[] = {
6454         /* Line In pin widget for input */
6455         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6456         /* CD pin widget for input */
6457         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6458         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6459         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6460         /* Mic2 (front panel) pin widget for input and vref at 80% */
6461         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6462         /* LINE-2 is used for line-out in rear */
6463         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6464         /* select line-out */
6465         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
6466         /* LINE-OUT pin */
6467         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6468         /* enable HP */
6469         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6470         /* enable Mono */
6471         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6472         /* mute capture amp left and right */
6473         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6474         /* set connection select to line in (default select for this ADC) */
6475         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6476         /* mute capture amp left and right */
6477         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6478         /* set connection select to line in (default select for this ADC) */
6479         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
6480         /* set vol=0 Line-Out mixer amp left and right */
6481         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6482         /* unmute pin widget amp left and right (no gain on this amp) */
6483         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6484         /* set vol=0 HP mixer amp left and right */
6485         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6486         /* unmute pin widget amp left and right (no gain on this amp) */
6487         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6488         /* set vol=0 Mono mixer amp left and right */
6489         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6490         /* unmute pin widget amp left and right (no gain on this amp) */
6491         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6492         /* unmute LINE-2 out pin */
6493         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6494         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6495          * Line In 2 = 0x03
6496          */
6497         /* mute analog inputs */
6498         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6499         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6500         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6501         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6502         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6503         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6504         /* mute Front out path */
6505         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6506         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6507         /* mute Headphone out path */
6508         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6509         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6510         /* mute Mono out path */
6511         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6512         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6513         { }
6514 };
6515
6516 #if 0 /* should be identical with alc260_init_verbs? */
6517 static const struct hda_verb alc260_hp_init_verbs[] = {
6518         /* Headphone and output */
6519         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6520         /* mono output */
6521         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6522         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6523         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6524         /* Mic2 (front panel) pin widget for input and vref at 80% */
6525         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6526         /* Line In pin widget for input */
6527         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6528         /* Line-2 pin widget for output */
6529         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6530         /* CD pin widget for input */
6531         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6532         /* unmute amp left and right */
6533         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6534         /* set connection select to line in (default select for this ADC) */
6535         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6536         /* unmute Line-Out mixer amp left and right (volume = 0) */
6537         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6538         /* mute pin widget amp left and right (no gain on this amp) */
6539         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6540         /* unmute HP mixer amp left and right (volume = 0) */
6541         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6542         /* mute pin widget amp left and right (no gain on this amp) */
6543         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6544         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6545          * Line In 2 = 0x03
6546          */
6547         /* mute analog inputs */
6548         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6549         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6550         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6551         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6552         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6553         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6554         /* Unmute Front out path */
6555         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6556         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6557         /* Unmute Headphone out path */
6558         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6559         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6560         /* Unmute Mono out path */
6561         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6562         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6563         { }
6564 };
6565 #endif
6566
6567 static const struct hda_verb alc260_hp_3013_init_verbs[] = {
6568         /* Line out and output */
6569         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6570         /* mono output */
6571         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6572         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6573         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6574         /* Mic2 (front panel) pin widget for input and vref at 80% */
6575         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6576         /* Line In pin widget for input */
6577         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6578         /* Headphone pin widget for output */
6579         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6580         /* CD pin widget for input */
6581         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6582         /* unmute amp left and right */
6583         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6584         /* set connection select to line in (default select for this ADC) */
6585         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6586         /* unmute Line-Out mixer amp left and right (volume = 0) */
6587         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6588         /* mute pin widget amp left and right (no gain on this amp) */
6589         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6590         /* unmute HP mixer amp left and right (volume = 0) */
6591         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6592         /* mute pin widget amp left and right (no gain on this amp) */
6593         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6594         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6595          * Line In 2 = 0x03
6596          */
6597         /* mute analog inputs */
6598         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6599         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6600         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6601         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6602         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6603         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6604         /* Unmute Front out path */
6605         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6606         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6607         /* Unmute Headphone out path */
6608         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6609         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6610         /* Unmute Mono out path */
6611         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6612         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6613         { }
6614 };
6615
6616 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
6617  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
6618  * audio = 0x16, internal speaker = 0x10.
6619  */
6620 static const struct hda_verb alc260_fujitsu_init_verbs[] = {
6621         /* Disable all GPIOs */
6622         {0x01, AC_VERB_SET_GPIO_MASK, 0},
6623         /* Internal speaker is connected to headphone pin */
6624         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6625         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
6626         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6627         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
6628         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6629         /* Ensure all other unused pins are disabled and muted. */
6630         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6631         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6632         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6633         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6634         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6635         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6636         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6637         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6638
6639         /* Disable digital (SPDIF) pins */
6640         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6641         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6642
6643         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
6644          * when acting as an output.
6645          */
6646         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6647
6648         /* Start with output sum widgets muted and their output gains at min */
6649         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6650         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6651         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6652         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6653         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6654         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6655         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6656         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6657         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6658
6659         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
6660         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6661         /* Unmute Line1 pin widget output buffer since it starts as an output.
6662          * If the pin mode is changed by the user the pin mode control will
6663          * take care of enabling the pin's input/output buffers as needed.
6664          * Therefore there's no need to enable the input buffer at this
6665          * stage.
6666          */
6667         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6668         /* Unmute input buffer of pin widget used for Line-in (no equiv
6669          * mixer ctrl)
6670          */
6671         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6672
6673         /* Mute capture amp left and right */
6674         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6675         /* Set ADC connection select to match default mixer setting - line
6676          * in (on mic1 pin)
6677          */
6678         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6679
6680         /* Do the same for the second ADC: mute capture input amp and
6681          * set ADC connection to line in (on mic1 pin)
6682          */
6683         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6684         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6685
6686         /* Mute all inputs to mixer widget (even unconnected ones) */
6687         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6688         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6689         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6690         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6691         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6692         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6693         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6694         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6695
6696         { }
6697 };
6698
6699 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
6700  * similar laptops (adapted from Fujitsu init verbs).
6701  */
6702 static const struct hda_verb alc260_acer_init_verbs[] = {
6703         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
6704          * the headphone jack.  Turn this on and rely on the standard mute
6705          * methods whenever the user wants to turn these outputs off.
6706          */
6707         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6708         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6709         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6710         /* Internal speaker/Headphone jack is connected to Line-out pin */
6711         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6712         /* Internal microphone/Mic jack is connected to Mic1 pin */
6713         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6714         /* Line In jack is connected to Line1 pin */
6715         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6716         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
6717         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6718         /* Ensure all other unused pins are disabled and muted. */
6719         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6720         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6721         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6722         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6723         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6724         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6725         /* Disable digital (SPDIF) pins */
6726         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6727         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6728
6729         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6730          * bus when acting as outputs.
6731          */
6732         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6733         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6734
6735         /* Start with output sum widgets muted and their output gains at min */
6736         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6737         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6738         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6739         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6740         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6741         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6742         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6743         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6744         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6745
6746         /* Unmute Line-out pin widget amp left and right
6747          * (no equiv mixer ctrl)
6748          */
6749         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6750         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
6751         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6752         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6753          * inputs. If the pin mode is changed by the user the pin mode control
6754          * will take care of enabling the pin's input/output buffers as needed.
6755          * Therefore there's no need to enable the input buffer at this
6756          * stage.
6757          */
6758         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6759         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6760
6761         /* Mute capture amp left and right */
6762         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6763         /* Set ADC connection select to match default mixer setting - mic
6764          * (on mic1 pin)
6765          */
6766         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6767
6768         /* Do similar with the second ADC: mute capture input amp and
6769          * set ADC connection to mic to match ALSA's default state.
6770          */
6771         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6772         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6773
6774         /* Mute all inputs to mixer widget (even unconnected ones) */
6775         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6776         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6777         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6778         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6779         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6780         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6781         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6782         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6783
6784         { }
6785 };
6786
6787 /* Initialisation sequence for Maxdata Favorit 100XS
6788  * (adapted from Acer init verbs).
6789  */
6790 static const struct hda_verb alc260_favorit100_init_verbs[] = {
6791         /* GPIO 0 enables the output jack.
6792          * Turn this on and rely on the standard mute
6793          * methods whenever the user wants to turn these outputs off.
6794          */
6795         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6796         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6797         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6798         /* Line/Mic input jack is connected to Mic1 pin */
6799         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6800         /* Ensure all other unused pins are disabled and muted. */
6801         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6802         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6803         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6804         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6805         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6806         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6807         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6808         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6809         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6810         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6811         /* Disable digital (SPDIF) pins */
6812         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6813         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6814
6815         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6816          * bus when acting as outputs.
6817          */
6818         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6819         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6820
6821         /* Start with output sum widgets muted and their output gains at min */
6822         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6823         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6824         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6825         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6826         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6827         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6828         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6829         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6830         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6831
6832         /* Unmute Line-out pin widget amp left and right
6833          * (no equiv mixer ctrl)
6834          */
6835         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6836         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6837          * inputs. If the pin mode is changed by the user the pin mode control
6838          * will take care of enabling the pin's input/output buffers as needed.
6839          * Therefore there's no need to enable the input buffer at this
6840          * stage.
6841          */
6842         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6843
6844         /* Mute capture amp left and right */
6845         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6846         /* Set ADC connection select to match default mixer setting - mic
6847          * (on mic1 pin)
6848          */
6849         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6850
6851         /* Do similar with the second ADC: mute capture input amp and
6852          * set ADC connection to mic to match ALSA's default state.
6853          */
6854         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6855         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6856
6857         /* Mute all inputs to mixer widget (even unconnected ones) */
6858         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6859         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6860         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6861         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6862         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6863         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6864         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6865         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6866
6867         { }
6868 };
6869
6870 static const struct hda_verb alc260_will_verbs[] = {
6871         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6872         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6873         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6874         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6875         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6876         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6877         {}
6878 };
6879
6880 static const struct hda_verb alc260_replacer_672v_verbs[] = {
6881         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6882         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6883         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6884
6885         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6886         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6887         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6888
6889         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6890         {}
6891 };
6892
6893 /* toggle speaker-output according to the hp-jack state */
6894 static void alc260_replacer_672v_automute(struct hda_codec *codec)
6895 {
6896         unsigned int present;
6897
6898         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6899         present = snd_hda_jack_detect(codec, 0x0f);
6900         if (present) {
6901                 snd_hda_codec_write_cache(codec, 0x01, 0,
6902                                           AC_VERB_SET_GPIO_DATA, 1);
6903                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6904                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6905                                           PIN_HP);
6906         } else {
6907                 snd_hda_codec_write_cache(codec, 0x01, 0,
6908                                           AC_VERB_SET_GPIO_DATA, 0);
6909                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6910                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6911                                           PIN_OUT);
6912         }
6913 }
6914
6915 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6916                                        unsigned int res)
6917 {
6918         if ((res >> 26) == ALC880_HP_EVENT)
6919                 alc260_replacer_672v_automute(codec);
6920 }
6921
6922 static const struct hda_verb alc260_hp_dc7600_verbs[] = {
6923         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6924         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6925         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6926         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6927         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6928         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6929         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6930         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6931         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6932         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6933         {}
6934 };
6935
6936 /* Test configuration for debugging, modelled after the ALC880 test
6937  * configuration.
6938  */
6939 #ifdef CONFIG_SND_DEBUG
6940 static const hda_nid_t alc260_test_dac_nids[1] = {
6941         0x02,
6942 };
6943 static const hda_nid_t alc260_test_adc_nids[2] = {
6944         0x04, 0x05,
6945 };
6946 /* For testing the ALC260, each input MUX needs its own definition since
6947  * the signal assignments are different.  This assumes that the first ADC
6948  * is NID 0x04.
6949  */
6950 static const struct hda_input_mux alc260_test_capture_sources[2] = {
6951         {
6952                 .num_items = 7,
6953                 .items = {
6954                         { "MIC1 pin", 0x0 },
6955                         { "MIC2 pin", 0x1 },
6956                         { "LINE1 pin", 0x2 },
6957                         { "LINE2 pin", 0x3 },
6958                         { "CD pin", 0x4 },
6959                         { "LINE-OUT pin", 0x5 },
6960                         { "HP-OUT pin", 0x6 },
6961                 },
6962         },
6963         {
6964                 .num_items = 8,
6965                 .items = {
6966                         { "MIC1 pin", 0x0 },
6967                         { "MIC2 pin", 0x1 },
6968                         { "LINE1 pin", 0x2 },
6969                         { "LINE2 pin", 0x3 },
6970                         { "CD pin", 0x4 },
6971                         { "Mixer", 0x5 },
6972                         { "LINE-OUT pin", 0x6 },
6973                         { "HP-OUT pin", 0x7 },
6974                 },
6975         },
6976 };
6977 static const struct snd_kcontrol_new alc260_test_mixer[] = {
6978         /* Output driver widgets */
6979         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6980         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6981         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6982         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6983         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6984         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6985
6986         /* Modes for retasking pin widgets
6987          * Note: the ALC260 doesn't seem to act on requests to enable mic
6988          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6989          * mention this restriction.  At this stage it's not clear whether
6990          * this behaviour is intentional or is a hardware bug in chip
6991          * revisions available at least up until early 2006.  Therefore for
6992          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6993          * choices, but if it turns out that the lack of mic bias for these
6994          * NIDs is intentional we could change their modes from
6995          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6996          */
6997         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6998         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6999         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
7000         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
7001         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
7002         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
7003
7004         /* Loopback mixer controls */
7005         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
7006         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
7007         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
7008         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
7009         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
7010         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
7011         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
7012         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
7013         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
7014         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
7015         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
7016         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
7017         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
7018         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
7019
7020         /* Controls for GPIO pins, assuming they are configured as outputs */
7021         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
7022         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
7023         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
7024         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
7025
7026         /* Switches to allow the digital IO pins to be enabled.  The datasheet
7027          * is ambigious as to which NID is which; testing on laptops which
7028          * make this output available should provide clarification.
7029          */
7030         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
7031         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
7032
7033         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
7034          * this output to turn on an external amplifier.
7035          */
7036         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
7037         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
7038
7039         { } /* end */
7040 };
7041 static const struct hda_verb alc260_test_init_verbs[] = {
7042         /* Enable all GPIOs as outputs with an initial value of 0 */
7043         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
7044         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
7045         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
7046
7047         /* Enable retasking pins as output, initially without power amp */
7048         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7049         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7050         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7051         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7052         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7053         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7054
7055         /* Disable digital (SPDIF) pins initially, but users can enable
7056          * them via a mixer switch.  In the case of SPDIF-out, this initverb
7057          * payload also sets the generation to 0, output to be in "consumer"
7058          * PCM format, copyright asserted, no pre-emphasis and no validity
7059          * control.
7060          */
7061         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
7062         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
7063
7064         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
7065          * OUT1 sum bus when acting as an output.
7066          */
7067         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
7068         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
7069         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
7070         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
7071
7072         /* Start with output sum widgets muted and their output gains at min */
7073         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7074         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7075         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7076         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7077         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7078         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7079         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7080         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7081         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7082
7083         /* Unmute retasking pin widget output buffers since the default
7084          * state appears to be output.  As the pin mode is changed by the
7085          * user the pin mode control will take care of enabling the pin's
7086          * input/output buffers as needed.
7087          */
7088         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7089         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7090         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7091         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7092         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7093         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7094         /* Also unmute the mono-out pin widget */
7095         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7096
7097         /* Mute capture amp left and right */
7098         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7099         /* Set ADC connection select to match default mixer setting (mic1
7100          * pin)
7101          */
7102         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
7103
7104         /* Do the same for the second ADC: mute capture input amp and
7105          * set ADC connection to mic1 pin
7106          */
7107         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7108         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
7109
7110         /* Mute all inputs to mixer widget (even unconnected ones) */
7111         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
7112         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
7113         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
7114         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
7115         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
7116         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
7117         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
7118         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
7119
7120         { }
7121 };
7122 #endif
7123
7124 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
7125 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
7126
7127 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
7128 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
7129
7130 /*
7131  * for BIOS auto-configuration
7132  */
7133
7134 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
7135                                         const char *pfx, int *vol_bits)
7136 {
7137         hda_nid_t nid_vol;
7138         unsigned long vol_val, sw_val;
7139         int err;
7140
7141         if (nid >= 0x0f && nid < 0x11) {
7142                 nid_vol = nid - 0x7;
7143                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
7144                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
7145         } else if (nid == 0x11) {
7146                 nid_vol = nid - 0x7;
7147                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
7148                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
7149         } else if (nid >= 0x12 && nid <= 0x15) {
7150                 nid_vol = 0x08;
7151                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
7152                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
7153         } else
7154                 return 0; /* N/A */
7155
7156         if (!(*vol_bits & (1 << nid_vol))) {
7157                 /* first control for the volume widget */
7158                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
7159                 if (err < 0)
7160                         return err;
7161                 *vol_bits |= (1 << nid_vol);
7162         }
7163         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
7164         if (err < 0)
7165                 return err;
7166         return 1;
7167 }
7168
7169 /* add playback controls from the parsed DAC table */
7170 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
7171                                              const struct auto_pin_cfg *cfg)
7172 {
7173         hda_nid_t nid;
7174         int err;
7175         int vols = 0;
7176
7177         spec->multiout.num_dacs = 1;
7178         spec->multiout.dac_nids = spec->private_dac_nids;
7179         spec->private_dac_nids[0] = 0x02;
7180
7181         nid = cfg->line_out_pins[0];
7182         if (nid) {
7183                 const char *pfx;
7184                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
7185                         pfx = "Master";
7186                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
7187                         pfx = "Speaker";
7188                 else
7189                         pfx = "Front";
7190                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
7191                 if (err < 0)
7192                         return err;
7193         }
7194
7195         nid = cfg->speaker_pins[0];
7196         if (nid) {
7197                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
7198                 if (err < 0)
7199                         return err;
7200         }
7201
7202         nid = cfg->hp_pins[0];
7203         if (nid) {
7204                 err = alc260_add_playback_controls(spec, nid, "Headphone",
7205                                                    &vols);
7206                 if (err < 0)
7207                         return err;
7208         }
7209         return 0;
7210 }
7211
7212 /* create playback/capture controls for input pins */
7213 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
7214                                                 const struct auto_pin_cfg *cfg)
7215 {
7216         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
7217 }
7218
7219 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
7220                                               hda_nid_t nid, int pin_type,
7221                                               int sel_idx)
7222 {
7223         alc_set_pin_output(codec, nid, pin_type);
7224         /* need the manual connection? */
7225         if (nid >= 0x12) {
7226                 int idx = nid - 0x12;
7227                 snd_hda_codec_write(codec, idx + 0x0b, 0,
7228                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
7229         }
7230 }
7231
7232 static void alc260_auto_init_multi_out(struct hda_codec *codec)
7233 {
7234         struct alc_spec *spec = codec->spec;
7235         hda_nid_t nid;
7236
7237         nid = spec->autocfg.line_out_pins[0];
7238         if (nid) {
7239                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
7240                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
7241         }
7242
7243         nid = spec->autocfg.speaker_pins[0];
7244         if (nid)
7245                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
7246
7247         nid = spec->autocfg.hp_pins[0];
7248         if (nid)
7249                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
7250 }
7251
7252 #define ALC260_PIN_CD_NID               0x16
7253 static void alc260_auto_init_analog_input(struct hda_codec *codec)
7254 {
7255         struct alc_spec *spec = codec->spec;
7256         struct auto_pin_cfg *cfg = &spec->autocfg;
7257         int i;
7258
7259         for (i = 0; i < cfg->num_inputs; i++) {
7260                 hda_nid_t nid = cfg->inputs[i].pin;
7261                 if (nid >= 0x12) {
7262                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
7263                         if (nid != ALC260_PIN_CD_NID &&
7264                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
7265                                 snd_hda_codec_write(codec, nid, 0,
7266                                                     AC_VERB_SET_AMP_GAIN_MUTE,
7267                                                     AMP_OUT_MUTE);
7268                 }
7269         }
7270 }
7271
7272 #define alc260_auto_init_input_src      alc880_auto_init_input_src
7273
7274 /*
7275  * generic initialization of ADC, input mixers and output mixers
7276  */
7277 static const struct hda_verb alc260_volume_init_verbs[] = {
7278         /*
7279          * Unmute ADC0-1 and set the default input to mic-in
7280          */
7281         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
7282         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7283         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
7284         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7285
7286         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7287          * mixer widget
7288          * Note: PASD motherboards uses the Line In 2 as the input for
7289          * front panel mic (mic 2)
7290          */
7291         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7292         /* mute analog inputs */
7293         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7294         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7295         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7296         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7297         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7298
7299         /*
7300          * Set up output mixers (0x08 - 0x0a)
7301          */
7302         /* set vol=0 to output mixers */
7303         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7304         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7305         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7306         /* set up input amps for analog loopback */
7307         /* Amp Indices: DAC = 0, mixer = 1 */
7308         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7309         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7310         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7311         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7312         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7313         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7314
7315         { }
7316 };
7317
7318 static int alc260_parse_auto_config(struct hda_codec *codec)
7319 {
7320         struct alc_spec *spec = codec->spec;
7321         int err;
7322         static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
7323
7324         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
7325                                            alc260_ignore);
7326         if (err < 0)
7327                 return err;
7328         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
7329         if (err < 0)
7330                 return err;
7331         if (!spec->kctls.list)
7332                 return 0; /* can't find valid BIOS pin config */
7333         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
7334         if (err < 0)
7335                 return err;
7336
7337         spec->multiout.max_channels = 2;
7338
7339         if (spec->autocfg.dig_outs)
7340                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
7341         if (spec->kctls.list)
7342                 add_mixer(spec, spec->kctls.list);
7343
7344         add_verb(spec, alc260_volume_init_verbs);
7345
7346         spec->num_mux_defs = 1;
7347         spec->input_mux = &spec->private_imux[0];
7348
7349         alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
7350
7351         return 1;
7352 }
7353
7354 /* additional initialization for auto-configuration model */
7355 static void alc260_auto_init(struct hda_codec *codec)
7356 {
7357         struct alc_spec *spec = codec->spec;
7358         alc260_auto_init_multi_out(codec);
7359         alc260_auto_init_analog_input(codec);
7360         alc260_auto_init_input_src(codec);
7361         alc_auto_init_digital(codec);
7362         if (spec->unsol_event)
7363                 alc_inithook(codec);
7364 }
7365
7366 #ifdef CONFIG_SND_HDA_POWER_SAVE
7367 static const struct hda_amp_list alc260_loopbacks[] = {
7368         { 0x07, HDA_INPUT, 0 },
7369         { 0x07, HDA_INPUT, 1 },
7370         { 0x07, HDA_INPUT, 2 },
7371         { 0x07, HDA_INPUT, 3 },
7372         { 0x07, HDA_INPUT, 4 },
7373         { } /* end */
7374 };
7375 #endif
7376
7377 /*
7378  * Pin config fixes
7379  */
7380 enum {
7381         PINFIX_HP_DC5750,
7382 };
7383
7384 static const struct alc_fixup alc260_fixups[] = {
7385         [PINFIX_HP_DC5750] = {
7386                 .type = ALC_FIXUP_PINS,
7387                 .v.pins = (const struct alc_pincfg[]) {
7388                         { 0x11, 0x90130110 }, /* speaker */
7389                         { }
7390                 }
7391         },
7392 };
7393
7394 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
7395         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
7396         {}
7397 };
7398
7399 /*
7400  * ALC260 configurations
7401  */
7402 static const char * const alc260_models[ALC260_MODEL_LAST] = {
7403         [ALC260_BASIC]          = "basic",
7404         [ALC260_HP]             = "hp",
7405         [ALC260_HP_3013]        = "hp-3013",
7406         [ALC260_HP_DC7600]      = "hp-dc7600",
7407         [ALC260_FUJITSU_S702X]  = "fujitsu",
7408         [ALC260_ACER]           = "acer",
7409         [ALC260_WILL]           = "will",
7410         [ALC260_REPLACER_672V]  = "replacer",
7411         [ALC260_FAVORIT100]     = "favorit100",
7412 #ifdef CONFIG_SND_DEBUG
7413         [ALC260_TEST]           = "test",
7414 #endif
7415         [ALC260_AUTO]           = "auto",
7416 };
7417
7418 static const struct snd_pci_quirk alc260_cfg_tbl[] = {
7419         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
7420         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
7421         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
7422         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
7423         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
7424         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
7425         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
7426         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
7427         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
7428         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
7429         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
7430         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
7431         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
7432         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
7433         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
7434         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
7435         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
7436         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
7437         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
7438         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
7439         {}
7440 };
7441
7442 static const struct alc_config_preset alc260_presets[] = {
7443         [ALC260_BASIC] = {
7444                 .mixers = { alc260_base_output_mixer,
7445                             alc260_input_mixer },
7446                 .init_verbs = { alc260_init_verbs },
7447                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7448                 .dac_nids = alc260_dac_nids,
7449                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7450                 .adc_nids = alc260_dual_adc_nids,
7451                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7452                 .channel_mode = alc260_modes,
7453                 .input_mux = &alc260_capture_source,
7454         },
7455         [ALC260_HP] = {
7456                 .mixers = { alc260_hp_output_mixer,
7457                             alc260_input_mixer },
7458                 .init_verbs = { alc260_init_verbs,
7459                                 alc260_hp_unsol_verbs },
7460                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7461                 .dac_nids = alc260_dac_nids,
7462                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7463                 .adc_nids = alc260_adc_nids_alt,
7464                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7465                 .channel_mode = alc260_modes,
7466                 .input_mux = &alc260_capture_source,
7467                 .unsol_event = alc_sku_unsol_event,
7468                 .setup = alc260_hp_setup,
7469                 .init_hook = alc_inithook,
7470         },
7471         [ALC260_HP_DC7600] = {
7472                 .mixers = { alc260_hp_dc7600_mixer,
7473                             alc260_input_mixer },
7474                 .init_verbs = { alc260_init_verbs,
7475                                 alc260_hp_dc7600_verbs },
7476                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7477                 .dac_nids = alc260_dac_nids,
7478                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7479                 .adc_nids = alc260_adc_nids_alt,
7480                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7481                 .channel_mode = alc260_modes,
7482                 .input_mux = &alc260_capture_source,
7483                 .unsol_event = alc_sku_unsol_event,
7484                 .setup = alc260_hp_3012_setup,
7485                 .init_hook = alc_inithook,
7486         },
7487         [ALC260_HP_3013] = {
7488                 .mixers = { alc260_hp_3013_mixer,
7489                             alc260_input_mixer },
7490                 .init_verbs = { alc260_hp_3013_init_verbs,
7491                                 alc260_hp_3013_unsol_verbs },
7492                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7493                 .dac_nids = alc260_dac_nids,
7494                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7495                 .adc_nids = alc260_adc_nids_alt,
7496                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7497                 .channel_mode = alc260_modes,
7498                 .input_mux = &alc260_capture_source,
7499                 .unsol_event = alc_sku_unsol_event,
7500                 .setup = alc260_hp_3013_setup,
7501                 .init_hook = alc_inithook,
7502         },
7503         [ALC260_FUJITSU_S702X] = {
7504                 .mixers = { alc260_fujitsu_mixer },
7505                 .init_verbs = { alc260_fujitsu_init_verbs },
7506                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7507                 .dac_nids = alc260_dac_nids,
7508                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7509                 .adc_nids = alc260_dual_adc_nids,
7510                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7511                 .channel_mode = alc260_modes,
7512                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
7513                 .input_mux = alc260_fujitsu_capture_sources,
7514         },
7515         [ALC260_ACER] = {
7516                 .mixers = { alc260_acer_mixer },
7517                 .init_verbs = { alc260_acer_init_verbs },
7518                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7519                 .dac_nids = alc260_dac_nids,
7520                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7521                 .adc_nids = alc260_dual_adc_nids,
7522                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7523                 .channel_mode = alc260_modes,
7524                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
7525                 .input_mux = alc260_acer_capture_sources,
7526         },
7527         [ALC260_FAVORIT100] = {
7528                 .mixers = { alc260_favorit100_mixer },
7529                 .init_verbs = { alc260_favorit100_init_verbs },
7530                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7531                 .dac_nids = alc260_dac_nids,
7532                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7533                 .adc_nids = alc260_dual_adc_nids,
7534                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7535                 .channel_mode = alc260_modes,
7536                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
7537                 .input_mux = alc260_favorit100_capture_sources,
7538         },
7539         [ALC260_WILL] = {
7540                 .mixers = { alc260_will_mixer },
7541                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
7542                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7543                 .dac_nids = alc260_dac_nids,
7544                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7545                 .adc_nids = alc260_adc_nids,
7546                 .dig_out_nid = ALC260_DIGOUT_NID,
7547                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7548                 .channel_mode = alc260_modes,
7549                 .input_mux = &alc260_capture_source,
7550         },
7551         [ALC260_REPLACER_672V] = {
7552                 .mixers = { alc260_replacer_672v_mixer },
7553                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
7554                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7555                 .dac_nids = alc260_dac_nids,
7556                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7557                 .adc_nids = alc260_adc_nids,
7558                 .dig_out_nid = ALC260_DIGOUT_NID,
7559                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7560                 .channel_mode = alc260_modes,
7561                 .input_mux = &alc260_capture_source,
7562                 .unsol_event = alc260_replacer_672v_unsol_event,
7563                 .init_hook = alc260_replacer_672v_automute,
7564         },
7565 #ifdef CONFIG_SND_DEBUG
7566         [ALC260_TEST] = {
7567                 .mixers = { alc260_test_mixer },
7568                 .init_verbs = { alc260_test_init_verbs },
7569                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
7570                 .dac_nids = alc260_test_dac_nids,
7571                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
7572                 .adc_nids = alc260_test_adc_nids,
7573                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7574                 .channel_mode = alc260_modes,
7575                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
7576                 .input_mux = alc260_test_capture_sources,
7577         },
7578 #endif
7579 };
7580
7581 static int patch_alc260(struct hda_codec *codec)
7582 {
7583         struct alc_spec *spec;
7584         int err, board_config;
7585
7586         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7587         if (spec == NULL)
7588                 return -ENOMEM;
7589
7590         codec->spec = spec;
7591
7592         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
7593                                                   alc260_models,
7594                                                   alc260_cfg_tbl);
7595         if (board_config < 0) {
7596                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
7597                            codec->chip_name);
7598                 board_config = ALC260_AUTO;
7599         }
7600
7601         if (board_config == ALC260_AUTO) {
7602                 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
7603                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
7604         }
7605
7606         if (board_config == ALC260_AUTO) {
7607                 /* automatic parse from the BIOS config */
7608                 err = alc260_parse_auto_config(codec);
7609                 if (err < 0) {
7610                         alc_free(codec);
7611                         return err;
7612                 } else if (!err) {
7613                         printk(KERN_INFO
7614                                "hda_codec: Cannot set up configuration "
7615                                "from BIOS.  Using base mode...\n");
7616                         board_config = ALC260_BASIC;
7617                 }
7618         }
7619
7620         err = snd_hda_attach_beep_device(codec, 0x1);
7621         if (err < 0) {
7622                 alc_free(codec);
7623                 return err;
7624         }
7625
7626         if (board_config != ALC260_AUTO)
7627                 setup_preset(codec, &alc260_presets[board_config]);
7628
7629         spec->stream_analog_playback = &alc260_pcm_analog_playback;
7630         spec->stream_analog_capture = &alc260_pcm_analog_capture;
7631         spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
7632
7633         spec->stream_digital_playback = &alc260_pcm_digital_playback;
7634         spec->stream_digital_capture = &alc260_pcm_digital_capture;
7635
7636         if (!spec->adc_nids && spec->input_mux) {
7637                 /* check whether NID 0x04 is valid */
7638                 unsigned int wcap = get_wcaps(codec, 0x04);
7639                 wcap = get_wcaps_type(wcap);
7640                 /* get type */
7641                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
7642                         spec->adc_nids = alc260_adc_nids_alt;
7643                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
7644                 } else {
7645                         spec->adc_nids = alc260_adc_nids;
7646                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
7647                 }
7648         }
7649         set_capture_mixer(codec);
7650         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
7651
7652         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
7653
7654         spec->vmaster_nid = 0x08;
7655
7656         codec->patch_ops = alc_patch_ops;
7657         if (board_config == ALC260_AUTO)
7658                 spec->init_hook = alc260_auto_init;
7659         spec->shutup = alc_eapd_shutup;
7660 #ifdef CONFIG_SND_HDA_POWER_SAVE
7661         if (!spec->loopback.amplist)
7662                 spec->loopback.amplist = alc260_loopbacks;
7663 #endif
7664
7665         return 0;
7666 }
7667
7668
7669 /*
7670  * ALC882/883/885/888/889 support
7671  *
7672  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
7673  * configuration.  Each pin widget can choose any input DACs and a mixer.
7674  * Each ADC is connected from a mixer of all inputs.  This makes possible
7675  * 6-channel independent captures.
7676  *
7677  * In addition, an independent DAC for the multi-playback (not used in this
7678  * driver yet).
7679  */
7680 #define ALC882_DIGOUT_NID       0x06
7681 #define ALC882_DIGIN_NID        0x0a
7682 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
7683 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
7684 #define ALC1200_DIGOUT_NID      0x10
7685
7686
7687 static const struct hda_channel_mode alc882_ch_modes[1] = {
7688         { 8, NULL }
7689 };
7690
7691 /* DACs */
7692 static const hda_nid_t alc882_dac_nids[4] = {
7693         /* front, rear, clfe, rear_surr */
7694         0x02, 0x03, 0x04, 0x05
7695 };
7696 #define alc883_dac_nids         alc882_dac_nids
7697
7698 /* ADCs */
7699 #define alc882_adc_nids         alc880_adc_nids
7700 #define alc882_adc_nids_alt     alc880_adc_nids_alt
7701 #define alc883_adc_nids         alc882_adc_nids_alt
7702 static const hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
7703 static const hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
7704 #define alc889_adc_nids         alc880_adc_nids
7705
7706 static const hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
7707 static const hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
7708 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
7709 static const hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7710 #define alc889_capsrc_nids      alc882_capsrc_nids
7711
7712 /* input MUX */
7713 /* FIXME: should be a matrix-type input source selection */
7714
7715 static const struct hda_input_mux alc882_capture_source = {
7716         .num_items = 4,
7717         .items = {
7718                 { "Mic", 0x0 },
7719                 { "Front Mic", 0x1 },
7720                 { "Line", 0x2 },
7721                 { "CD", 0x4 },
7722         },
7723 };
7724
7725 #define alc883_capture_source   alc882_capture_source
7726
7727 static const struct hda_input_mux alc889_capture_source = {
7728         .num_items = 3,
7729         .items = {
7730                 { "Front Mic", 0x0 },
7731                 { "Mic", 0x3 },
7732                 { "Line", 0x2 },
7733         },
7734 };
7735
7736 static const struct hda_input_mux mb5_capture_source = {
7737         .num_items = 3,
7738         .items = {
7739                 { "Mic", 0x1 },
7740                 { "Line", 0x7 },
7741                 { "CD", 0x4 },
7742         },
7743 };
7744
7745 static const struct hda_input_mux macmini3_capture_source = {
7746         .num_items = 2,
7747         .items = {
7748                 { "Line", 0x2 },
7749                 { "CD", 0x4 },
7750         },
7751 };
7752
7753 static const struct hda_input_mux alc883_3stack_6ch_intel = {
7754         .num_items = 4,
7755         .items = {
7756                 { "Mic", 0x1 },
7757                 { "Front Mic", 0x0 },
7758                 { "Line", 0x2 },
7759                 { "CD", 0x4 },
7760         },
7761 };
7762
7763 static const struct hda_input_mux alc883_lenovo_101e_capture_source = {
7764         .num_items = 2,
7765         .items = {
7766                 { "Mic", 0x1 },
7767                 { "Line", 0x2 },
7768         },
7769 };
7770
7771 static const struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7772         .num_items = 4,
7773         .items = {
7774                 { "Mic", 0x0 },
7775                 { "Internal Mic", 0x1 },
7776                 { "Line", 0x2 },
7777                 { "CD", 0x4 },
7778         },
7779 };
7780
7781 static const struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7782         .num_items = 2,
7783         .items = {
7784                 { "Mic", 0x0 },
7785                 { "Internal Mic", 0x1 },
7786         },
7787 };
7788
7789 static const struct hda_input_mux alc883_lenovo_sky_capture_source = {
7790         .num_items = 3,
7791         .items = {
7792                 { "Mic", 0x0 },
7793                 { "Front Mic", 0x1 },
7794                 { "Line", 0x4 },
7795         },
7796 };
7797
7798 static const struct hda_input_mux alc883_asus_eee1601_capture_source = {
7799         .num_items = 2,
7800         .items = {
7801                 { "Mic", 0x0 },
7802                 { "Line", 0x2 },
7803         },
7804 };
7805
7806 static const struct hda_input_mux alc889A_mb31_capture_source = {
7807         .num_items = 2,
7808         .items = {
7809                 { "Mic", 0x0 },
7810                 /* Front Mic (0x01) unused */
7811                 { "Line", 0x2 },
7812                 /* Line 2 (0x03) unused */
7813                 /* CD (0x04) unused? */
7814         },
7815 };
7816
7817 static const struct hda_input_mux alc889A_imac91_capture_source = {
7818         .num_items = 2,
7819         .items = {
7820                 { "Mic", 0x01 },
7821                 { "Line", 0x2 }, /* Not sure! */
7822         },
7823 };
7824
7825 /*
7826  * 2ch mode
7827  */
7828 static const struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7829         { 2, NULL }
7830 };
7831
7832 /*
7833  * 2ch mode
7834  */
7835 static const struct hda_verb alc882_3ST_ch2_init[] = {
7836         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7837         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7838         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7839         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7840         { } /* end */
7841 };
7842
7843 /*
7844  * 4ch mode
7845  */
7846 static const struct hda_verb alc882_3ST_ch4_init[] = {
7847         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7848         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7849         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7850         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7851         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7852         { } /* end */
7853 };
7854
7855 /*
7856  * 6ch mode
7857  */
7858 static const struct hda_verb alc882_3ST_ch6_init[] = {
7859         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7860         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7861         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7862         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7863         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7864         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7865         { } /* end */
7866 };
7867
7868 static const struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
7869         { 2, alc882_3ST_ch2_init },
7870         { 4, alc882_3ST_ch4_init },
7871         { 6, alc882_3ST_ch6_init },
7872 };
7873
7874 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
7875
7876 /*
7877  * 2ch mode
7878  */
7879 static const struct hda_verb alc883_3ST_ch2_clevo_init[] = {
7880         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
7881         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7882         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7883         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7884         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7885         { } /* end */
7886 };
7887
7888 /*
7889  * 4ch mode
7890  */
7891 static const struct hda_verb alc883_3ST_ch4_clevo_init[] = {
7892         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7893         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7894         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7895         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7896         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7897         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7898         { } /* end */
7899 };
7900
7901 /*
7902  * 6ch mode
7903  */
7904 static const struct hda_verb alc883_3ST_ch6_clevo_init[] = {
7905         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7906         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7907         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7908         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7909         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7910         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7911         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7912         { } /* end */
7913 };
7914
7915 static const struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
7916         { 2, alc883_3ST_ch2_clevo_init },
7917         { 4, alc883_3ST_ch4_clevo_init },
7918         { 6, alc883_3ST_ch6_clevo_init },
7919 };
7920
7921
7922 /*
7923  * 6ch mode
7924  */
7925 static const struct hda_verb alc882_sixstack_ch6_init[] = {
7926         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7927         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7928         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7929         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7930         { } /* end */
7931 };
7932
7933 /*
7934  * 8ch mode
7935  */
7936 static const struct hda_verb alc882_sixstack_ch8_init[] = {
7937         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7938         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7939         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7940         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7941         { } /* end */
7942 };
7943
7944 static const struct hda_channel_mode alc882_sixstack_modes[2] = {
7945         { 6, alc882_sixstack_ch6_init },
7946         { 8, alc882_sixstack_ch8_init },
7947 };
7948
7949
7950 /* Macbook Air 2,1 */
7951
7952 static const struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7953       { 2, NULL },
7954 };
7955
7956 /*
7957  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7958  */
7959
7960 /*
7961  * 2ch mode
7962  */
7963 static const struct hda_verb alc885_mbp_ch2_init[] = {
7964         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7965         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7966         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7967         { } /* end */
7968 };
7969
7970 /*
7971  * 4ch mode
7972  */
7973 static const struct hda_verb alc885_mbp_ch4_init[] = {
7974         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7975         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7976         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7977         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7978         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7979         { } /* end */
7980 };
7981
7982 static const struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7983         { 2, alc885_mbp_ch2_init },
7984         { 4, alc885_mbp_ch4_init },
7985 };
7986
7987 /*
7988  * 2ch
7989  * Speakers/Woofer/HP = Front
7990  * LineIn = Input
7991  */
7992 static const struct hda_verb alc885_mb5_ch2_init[] = {
7993         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7994         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7995         { } /* end */
7996 };
7997
7998 /*
7999  * 6ch mode
8000  * Speakers/HP = Front
8001  * Woofer = LFE
8002  * LineIn = Surround
8003  */
8004 static const struct hda_verb alc885_mb5_ch6_init[] = {
8005         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8006         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8007         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8008         { } /* end */
8009 };
8010
8011 static const struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
8012         { 2, alc885_mb5_ch2_init },
8013         { 6, alc885_mb5_ch6_init },
8014 };
8015
8016 #define alc885_macmini3_6ch_modes       alc885_mb5_6ch_modes
8017
8018 /*
8019  * 2ch mode
8020  */
8021 static const struct hda_verb alc883_4ST_ch2_init[] = {
8022         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8023         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8024         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8025         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8026         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8027         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8028         { } /* end */
8029 };
8030
8031 /*
8032  * 4ch mode
8033  */
8034 static const struct hda_verb alc883_4ST_ch4_init[] = {
8035         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8036         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8037         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8038         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8039         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8040         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8041         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8042         { } /* end */
8043 };
8044
8045 /*
8046  * 6ch mode
8047  */
8048 static const struct hda_verb alc883_4ST_ch6_init[] = {
8049         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8050         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8051         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8052         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8053         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8054         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8055         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8056         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8057         { } /* end */
8058 };
8059
8060 /*
8061  * 8ch mode
8062  */
8063 static const struct hda_verb alc883_4ST_ch8_init[] = {
8064         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8065         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8066         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
8067         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8068         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8069         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8070         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8071         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8072         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8073         { } /* end */
8074 };
8075
8076 static const struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
8077         { 2, alc883_4ST_ch2_init },
8078         { 4, alc883_4ST_ch4_init },
8079         { 6, alc883_4ST_ch6_init },
8080         { 8, alc883_4ST_ch8_init },
8081 };
8082
8083
8084 /*
8085  * 2ch mode
8086  */
8087 static const struct hda_verb alc883_3ST_ch2_intel_init[] = {
8088         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8089         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8090         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8091         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8092         { } /* end */
8093 };
8094
8095 /*
8096  * 4ch mode
8097  */
8098 static const struct hda_verb alc883_3ST_ch4_intel_init[] = {
8099         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8100         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8101         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8102         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8103         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8104         { } /* end */
8105 };
8106
8107 /*
8108  * 6ch mode
8109  */
8110 static const struct hda_verb alc883_3ST_ch6_intel_init[] = {
8111         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8112         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8113         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
8114         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8115         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8116         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8117         { } /* end */
8118 };
8119
8120 static const struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
8121         { 2, alc883_3ST_ch2_intel_init },
8122         { 4, alc883_3ST_ch4_intel_init },
8123         { 6, alc883_3ST_ch6_intel_init },
8124 };
8125
8126 /*
8127  * 2ch mode
8128  */
8129 static const struct hda_verb alc889_ch2_intel_init[] = {
8130         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
8131         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
8132         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
8133         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
8134         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8135         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8136         { } /* end */
8137 };
8138
8139 /*
8140  * 6ch mode
8141  */
8142 static const struct hda_verb alc889_ch6_intel_init[] = {
8143         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
8144         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
8145         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
8146         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
8147         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8148         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8149         { } /* end */
8150 };
8151
8152 /*
8153  * 8ch mode
8154  */
8155 static const struct hda_verb alc889_ch8_intel_init[] = {
8156         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
8157         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
8158         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
8159         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
8160         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
8161         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8162         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8163         { } /* end */
8164 };
8165
8166 static const struct hda_channel_mode alc889_8ch_intel_modes[3] = {
8167         { 2, alc889_ch2_intel_init },
8168         { 6, alc889_ch6_intel_init },
8169         { 8, alc889_ch8_intel_init },
8170 };
8171
8172 /*
8173  * 6ch mode
8174  */
8175 static const struct hda_verb alc883_sixstack_ch6_init[] = {
8176         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
8177         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8178         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8179         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8180         { } /* end */
8181 };
8182
8183 /*
8184  * 8ch mode
8185  */
8186 static const struct hda_verb alc883_sixstack_ch8_init[] = {
8187         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8188         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8189         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8190         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8191         { } /* end */
8192 };
8193
8194 static const struct hda_channel_mode alc883_sixstack_modes[2] = {
8195         { 6, alc883_sixstack_ch6_init },
8196         { 8, alc883_sixstack_ch8_init },
8197 };
8198
8199
8200 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
8201  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
8202  */
8203 static const struct snd_kcontrol_new alc882_base_mixer[] = {
8204         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8205         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8206         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8207         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8208         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8209         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8210         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8211         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8212         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8213         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8214         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8215         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8216         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8217         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8218         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8219         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8220         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8221         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8222         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8223         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8224         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8225         { } /* end */
8226 };
8227
8228 /* Macbook Air 2,1 same control for HP and internal Speaker */
8229
8230 static const struct snd_kcontrol_new alc885_mba21_mixer[] = {
8231       HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8232       HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
8233      { }
8234 };
8235
8236
8237 static const struct snd_kcontrol_new alc885_mbp3_mixer[] = {
8238         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8239         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
8240         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8241         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
8242         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8243         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8244         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8245         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8246         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8247         HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT),
8248         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT),
8249         { } /* end */
8250 };
8251
8252 static const struct snd_kcontrol_new alc885_mb5_mixer[] = {
8253         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8254         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8255         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8256         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8257         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8258         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
8259         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
8260         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
8261         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
8262         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
8263         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8264         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8265         HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT),
8266         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0x00, HDA_INPUT),
8267         { } /* end */
8268 };
8269
8270 static const struct snd_kcontrol_new alc885_macmini3_mixer[] = {
8271         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8272         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8273         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8274         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8275         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8276         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
8277         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
8278         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
8279         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
8280         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
8281         HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT),
8282         { } /* end */
8283 };
8284
8285 static const struct snd_kcontrol_new alc885_imac91_mixer[] = {
8286         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8287         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
8288         { } /* end */
8289 };
8290
8291
8292 static const struct snd_kcontrol_new alc882_w2jc_mixer[] = {
8293         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8294         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8295         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8296         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8297         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8298         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8299         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8300         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8301         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8302         { } /* end */
8303 };
8304
8305 static const struct snd_kcontrol_new alc882_targa_mixer[] = {
8306         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8307         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8308         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8309         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8310         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8311         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8312         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8313         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8314         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8315         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8316         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8317         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8318         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8319         { } /* end */
8320 };
8321
8322 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
8323  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
8324  */
8325 static const struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
8326         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8327         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8328         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8329         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
8330         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8331         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8332         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8333         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8334         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
8335         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
8336         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8337         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8338         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8339         { } /* end */
8340 };
8341
8342 static const struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
8343         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8344         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8345         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8346         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8347         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8348         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8349         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8350         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8351         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8352         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8353         { } /* end */
8354 };
8355
8356 static const struct snd_kcontrol_new alc882_chmode_mixer[] = {
8357         {
8358                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8359                 .name = "Channel Mode",
8360                 .info = alc_ch_mode_info,
8361                 .get = alc_ch_mode_get,
8362                 .put = alc_ch_mode_put,
8363         },
8364         { } /* end */
8365 };
8366
8367 static const struct hda_verb alc882_base_init_verbs[] = {
8368         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8369         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8370         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8371         /* Rear mixer */
8372         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8373         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8374         /* CLFE mixer */
8375         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8376         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8377         /* Side mixer */
8378         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8379         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8380
8381         /* Front Pin: output 0 (0x0c) */
8382         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8383         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8384         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8385         /* Rear Pin: output 1 (0x0d) */
8386         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8387         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8388         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8389         /* CLFE Pin: output 2 (0x0e) */
8390         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8391         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8392         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8393         /* Side Pin: output 3 (0x0f) */
8394         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8395         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8396         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8397         /* Mic (rear) pin: input vref at 80% */
8398         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8399         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8400         /* Front Mic pin: input vref at 80% */
8401         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8402         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8403         /* Line In pin: input */
8404         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8405         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8406         /* Line-2 In: Headphone output (output 0 - 0x0c) */
8407         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8408         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8409         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8410         /* CD pin widget for input */
8411         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8412
8413         /* FIXME: use matrix-type input source selection */
8414         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8415         /* Input mixer2 */
8416         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8417         /* Input mixer3 */
8418         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8419         /* ADC2: mute amp left and right */
8420         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8421         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8422         /* ADC3: mute amp left and right */
8423         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8424         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8425
8426         { }
8427 };
8428
8429 static const struct hda_verb alc882_adc1_init_verbs[] = {
8430         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8431         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8432         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8433         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8434         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8435         /* ADC1: mute amp left and right */
8436         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8437         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8438         { }
8439 };
8440
8441 static const struct hda_verb alc882_eapd_verbs[] = {
8442         /* change to EAPD mode */
8443         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8444         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
8445         { }
8446 };
8447
8448 static const struct hda_verb alc889_eapd_verbs[] = {
8449         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
8450         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
8451         { }
8452 };
8453
8454 static const struct hda_verb alc_hp15_unsol_verbs[] = {
8455         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8456         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8457         {}
8458 };
8459
8460 static const struct hda_verb alc885_init_verbs[] = {
8461         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8462         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8463         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8464         /* Rear mixer */
8465         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8466         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8467         /* CLFE mixer */
8468         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8469         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8470         /* Side mixer */
8471         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8472         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8473
8474         /* Front HP Pin: output 0 (0x0c) */
8475         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8476         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8477         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8478         /* Front Pin: output 0 (0x0c) */
8479         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8480         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8481         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8482         /* Rear Pin: output 1 (0x0d) */
8483         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8484         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8485         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
8486         /* CLFE Pin: output 2 (0x0e) */
8487         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8488         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8489         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8490         /* Side Pin: output 3 (0x0f) */
8491         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8492         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8493         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8494         /* Mic (rear) pin: input vref at 80% */
8495         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8496         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8497         /* Front Mic pin: input vref at 80% */
8498         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8499         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8500         /* Line In pin: input */
8501         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8502         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8503
8504         /* Mixer elements: 0x18, , 0x1a, 0x1b */
8505         /* Input mixer1 */
8506         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8507         /* Input mixer2 */
8508         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8509         /* Input mixer3 */
8510         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8511         /* ADC2: mute amp left and right */
8512         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8513         /* ADC3: mute amp left and right */
8514         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8515
8516         { }
8517 };
8518
8519 static const struct hda_verb alc885_init_input_verbs[] = {
8520         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8521         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8522         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
8523         { }
8524 };
8525
8526
8527 /* Unmute Selector 24h and set the default input to front mic */
8528 static const struct hda_verb alc889_init_input_verbs[] = {
8529         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
8530         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8531         { }
8532 };
8533
8534
8535 #define alc883_init_verbs       alc882_base_init_verbs
8536
8537 /* Mac Pro test */
8538 static const struct snd_kcontrol_new alc882_macpro_mixer[] = {
8539         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8540         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8541         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
8542         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8543         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8544         /* FIXME: this looks suspicious...
8545         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
8546         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
8547         */
8548         { } /* end */
8549 };
8550
8551 static const struct hda_verb alc882_macpro_init_verbs[] = {
8552         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8553         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8554         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8555         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8556         /* Front Pin: output 0 (0x0c) */
8557         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8558         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8559         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8560         /* Front Mic pin: input vref at 80% */
8561         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8562         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8563         /* Speaker:  output */
8564         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8565         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8566         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
8567         /* Headphone output (output 0 - 0x0c) */
8568         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8569         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8570         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8571
8572         /* FIXME: use matrix-type input source selection */
8573         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8574         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8575         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8576         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8577         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8578         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8579         /* Input mixer2 */
8580         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8581         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8582         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8583         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8584         /* Input mixer3 */
8585         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8586         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8587         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8588         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8589         /* ADC1: mute amp left and right */
8590         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8591         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8592         /* ADC2: mute amp left and right */
8593         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8594         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8595         /* ADC3: mute amp left and right */
8596         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8597         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8598
8599         { }
8600 };
8601
8602 /* Macbook 5,1 */
8603 static const struct hda_verb alc885_mb5_init_verbs[] = {
8604         /* DACs */
8605         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8606         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8607         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8608         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8609         /* Front mixer */
8610         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8611         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8612         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8613         /* Surround mixer */
8614         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8615         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8616         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8617         /* LFE mixer */
8618         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8619         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8620         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8621         /* HP mixer */
8622         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8623         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8624         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8625         /* Front Pin (0x0c) */
8626         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8627         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8628         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8629         /* LFE Pin (0x0e) */
8630         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8631         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8632         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8633         /* HP Pin (0x0f) */
8634         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8635         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8636         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8637         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8638         /* Front Mic pin: input vref at 80% */
8639         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8640         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8641         /* Line In pin */
8642         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8643         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8644
8645         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)},
8646         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)},
8647         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)},
8648         { }
8649 };
8650
8651 /* Macmini 3,1 */
8652 static const struct hda_verb alc885_macmini3_init_verbs[] = {
8653         /* DACs */
8654         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8655         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8656         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8657         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8658         /* Front mixer */
8659         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8660         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8661         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8662         /* Surround mixer */
8663         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8664         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8665         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8666         /* LFE mixer */
8667         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8668         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8669         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8670         /* HP mixer */
8671         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8672         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8673         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8674         /* Front Pin (0x0c) */
8675         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8676         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8677         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8678         /* LFE Pin (0x0e) */
8679         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8680         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8681         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8682         /* HP Pin (0x0f) */
8683         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8684         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8685         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8686         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8687         /* Line In pin */
8688         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8689         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8690
8691         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8692         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8693         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8694         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8695         { }
8696 };
8697
8698
8699 static const struct hda_verb alc885_mba21_init_verbs[] = {
8700         /*Internal and HP Speaker Mixer*/
8701         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8702         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8703         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8704         /*Internal Speaker Pin (0x0c)*/
8705         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8706         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8707         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8708         /* HP Pin: output 0 (0x0e) */
8709         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8710         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8711         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8712         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8713         /* Line in (is hp when jack connected)*/
8714         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8715         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8716
8717         { }
8718  };
8719
8720
8721 /* Macbook Pro rev3 */
8722 static const struct hda_verb alc885_mbp3_init_verbs[] = {
8723         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8724         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8725         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8726         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8727         /* Rear mixer */
8728         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8729         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8730         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8731         /* HP mixer */
8732         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8733         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8734         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8735         /* Front Pin: output 0 (0x0c) */
8736         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8737         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8738         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8739         /* HP Pin: output 0 (0x0e) */
8740         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8741         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8742         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
8743         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8744         /* Mic (rear) pin: input vref at 80% */
8745         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8746         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8747         /* Front Mic pin: input vref at 80% */
8748         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8749         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8750         /* Line In pin: use output 1 when in LineOut mode */
8751         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8752         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8753         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8754
8755         /* FIXME: use matrix-type input source selection */
8756         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8757         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8758         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8759         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8760         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8761         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8762         /* Input mixer2 */
8763         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8764         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8765         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8766         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8767         /* Input mixer3 */
8768         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8769         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8770         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8771         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8772         /* ADC1: mute amp left and right */
8773         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8774         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8775         /* ADC2: mute amp left and right */
8776         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8777         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8778         /* ADC3: mute amp left and right */
8779         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8780         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8781
8782         { }
8783 };
8784
8785 /* iMac 9,1 */
8786 static const struct hda_verb alc885_imac91_init_verbs[] = {
8787         /* Internal Speaker Pin (0x0c) */
8788         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8789         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8790         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8791         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8792         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8793         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8794         /* HP Pin: Rear */
8795         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8796         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8797         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8798         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8799         /* Line in Rear */
8800         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8801         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8802         /* Front Mic pin: input vref at 80% */
8803         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8804         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8805         /* Rear mixer */
8806         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8807         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8808         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8809         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
8810         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8811         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8812         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8813         /* 0x24 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8814         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8815         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8816         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8817         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8818         /* 0x23 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8819         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8820         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8821         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8822         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8823         /* 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8824         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8825         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8826         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8827         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8828         /* 0x07 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8829         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8830         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8831         /* 0x08 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8832         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8833         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8834         /* 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8835         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8836         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8837         { }
8838 };
8839
8840 /* iMac 24 mixer. */
8841 static const struct snd_kcontrol_new alc885_imac24_mixer[] = {
8842         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8843         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
8844         { } /* end */
8845 };
8846
8847 /* iMac 24 init verbs. */
8848 static const struct hda_verb alc885_imac24_init_verbs[] = {
8849         /* Internal speakers: output 0 (0x0c) */
8850         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8851         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8852         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8853         /* Internal speakers: output 0 (0x0c) */
8854         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8855         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8856         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8857         /* Headphone: output 0 (0x0c) */
8858         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8859         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8860         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8861         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8862         /* Front Mic: input vref at 80% */
8863         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8864         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8865         { }
8866 };
8867
8868 /* Toggle speaker-output according to the hp-jack state */
8869 static void alc885_imac24_setup(struct hda_codec *codec)
8870 {
8871         struct alc_spec *spec = codec->spec;
8872
8873         spec->autocfg.hp_pins[0] = 0x14;
8874         spec->autocfg.speaker_pins[0] = 0x18;
8875         spec->autocfg.speaker_pins[1] = 0x1a;
8876         spec->automute = 1;
8877         spec->automute_mode = ALC_AUTOMUTE_AMP;
8878 }
8879
8880 #define alc885_mb5_setup        alc885_imac24_setup
8881 #define alc885_macmini3_setup   alc885_imac24_setup
8882
8883 /* Macbook Air 2,1 */
8884 static void alc885_mba21_setup(struct hda_codec *codec)
8885 {
8886        struct alc_spec *spec = codec->spec;
8887
8888        spec->autocfg.hp_pins[0] = 0x14;
8889        spec->autocfg.speaker_pins[0] = 0x18;
8890         spec->automute = 1;
8891         spec->automute_mode = ALC_AUTOMUTE_AMP;
8892 }
8893
8894
8895
8896 static void alc885_mbp3_setup(struct hda_codec *codec)
8897 {
8898         struct alc_spec *spec = codec->spec;
8899
8900         spec->autocfg.hp_pins[0] = 0x15;
8901         spec->autocfg.speaker_pins[0] = 0x14;
8902         spec->automute = 1;
8903         spec->automute_mode = ALC_AUTOMUTE_AMP;
8904 }
8905
8906 static void alc885_imac91_setup(struct hda_codec *codec)
8907 {
8908         struct alc_spec *spec = codec->spec;
8909
8910         spec->autocfg.hp_pins[0] = 0x14;
8911         spec->autocfg.speaker_pins[0] = 0x18;
8912         spec->autocfg.speaker_pins[1] = 0x1a;
8913         spec->automute = 1;
8914         spec->automute_mode = ALC_AUTOMUTE_AMP;
8915 }
8916
8917 static const struct hda_verb alc882_targa_verbs[] = {
8918         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8919         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8920
8921         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8922         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8923
8924         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8925         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8926         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8927
8928         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8929         { } /* end */
8930 };
8931
8932 /* toggle speaker-output according to the hp-jack state */
8933 static void alc882_targa_automute(struct hda_codec *codec)
8934 {
8935         struct alc_spec *spec = codec->spec;
8936         alc_hp_automute(codec);
8937         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8938                                   spec->jack_present ? 1 : 3);
8939 }
8940
8941 static void alc882_targa_setup(struct hda_codec *codec)
8942 {
8943         struct alc_spec *spec = codec->spec;
8944
8945         spec->autocfg.hp_pins[0] = 0x14;
8946         spec->autocfg.speaker_pins[0] = 0x1b;
8947         spec->automute = 1;
8948         spec->automute_mode = ALC_AUTOMUTE_AMP;
8949 }
8950
8951 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8952 {
8953         if ((res >> 26) == ALC880_HP_EVENT)
8954                 alc882_targa_automute(codec);
8955 }
8956
8957 static const struct hda_verb alc882_asus_a7j_verbs[] = {
8958         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8959         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8960
8961         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8962         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8963         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8964
8965         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8966         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8967         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8968
8969         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8970         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8971         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8972         { } /* end */
8973 };
8974
8975 static const struct hda_verb alc882_asus_a7m_verbs[] = {
8976         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8977         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8978
8979         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8980         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8981         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8982
8983         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8984         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8985         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8986
8987         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8988         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8989         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8990         { } /* end */
8991 };
8992
8993 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8994 {
8995         unsigned int gpiostate, gpiomask, gpiodir;
8996
8997         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8998                                        AC_VERB_GET_GPIO_DATA, 0);
8999
9000         if (!muted)
9001                 gpiostate |= (1 << pin);
9002         else
9003                 gpiostate &= ~(1 << pin);
9004
9005         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
9006                                       AC_VERB_GET_GPIO_MASK, 0);
9007         gpiomask |= (1 << pin);
9008
9009         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
9010                                      AC_VERB_GET_GPIO_DIRECTION, 0);
9011         gpiodir |= (1 << pin);
9012
9013
9014         snd_hda_codec_write(codec, codec->afg, 0,
9015                             AC_VERB_SET_GPIO_MASK, gpiomask);
9016         snd_hda_codec_write(codec, codec->afg, 0,
9017                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
9018
9019         msleep(1);
9020
9021         snd_hda_codec_write(codec, codec->afg, 0,
9022                             AC_VERB_SET_GPIO_DATA, gpiostate);
9023 }
9024
9025 /* set up GPIO at initialization */
9026 static void alc885_macpro_init_hook(struct hda_codec *codec)
9027 {
9028         alc882_gpio_mute(codec, 0, 0);
9029         alc882_gpio_mute(codec, 1, 0);
9030 }
9031
9032 /* set up GPIO and update auto-muting at initialization */
9033 static void alc885_imac24_init_hook(struct hda_codec *codec)
9034 {
9035         alc885_macpro_init_hook(codec);
9036         alc_hp_automute(codec);
9037 }
9038
9039 /*
9040  * generic initialization of ADC, input mixers and output mixers
9041  */
9042 static const struct hda_verb alc883_auto_init_verbs[] = {
9043         /*
9044          * Unmute ADC0-2 and set the default input to mic-in
9045          */
9046         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9047         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9048         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9049         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9050
9051         /*
9052          * Set up output mixers (0x0c - 0x0f)
9053          */
9054         /* set vol=0 to output mixers */
9055         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9056         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9057         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9058         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9059         /* set up input amps for analog loopback */
9060         /* Amp Indices: DAC = 0, mixer = 1 */
9061         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9062         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9063         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9064         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9065         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9066         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9067         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9068         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9069         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9070         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9071
9072         /* FIXME: use matrix-type input source selection */
9073         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9074         /* Input mixer2 */
9075         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9076         /* Input mixer3 */
9077         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9078         { }
9079 };
9080
9081 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
9082 static const struct hda_verb alc889A_mb31_ch2_init[] = {
9083         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
9084         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
9085         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
9086         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
9087         { } /* end */
9088 };
9089
9090 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
9091 static const struct hda_verb alc889A_mb31_ch4_init[] = {
9092         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
9093         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
9094         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
9095         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
9096         { } /* end */
9097 };
9098
9099 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
9100 static const struct hda_verb alc889A_mb31_ch5_init[] = {
9101         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
9102         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
9103         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
9104         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
9105         { } /* end */
9106 };
9107
9108 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
9109 static const struct hda_verb alc889A_mb31_ch6_init[] = {
9110         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
9111         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
9112         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
9113         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
9114         { } /* end */
9115 };
9116
9117 static const struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
9118         { 2, alc889A_mb31_ch2_init },
9119         { 4, alc889A_mb31_ch4_init },
9120         { 5, alc889A_mb31_ch5_init },
9121         { 6, alc889A_mb31_ch6_init },
9122 };
9123
9124 static const struct hda_verb alc883_medion_eapd_verbs[] = {
9125         /* eanable EAPD on medion laptop */
9126         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9127         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
9128         { }
9129 };
9130
9131 #define alc883_base_mixer       alc882_base_mixer
9132
9133 static const struct snd_kcontrol_new alc883_mitac_mixer[] = {
9134         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9135         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9136         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9137         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9138         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9139         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9140         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9141         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9142         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9143         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9144         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9145         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9146         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9147         { } /* end */
9148 };
9149
9150 static const struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
9151         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9152         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
9153         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9154         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9155         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9156         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9157         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9158         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9159         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9160         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9161         { } /* end */
9162 };
9163
9164 static const struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
9165         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9166         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
9167         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9168         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9169         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9170         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9171         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9172         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9173         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9174         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9175         { } /* end */
9176 };
9177
9178 static const struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
9179         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9180         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9181         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9182         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9183         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9184         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9185         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9186         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9187         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9188         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9189         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9190         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9191         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9192         { } /* end */
9193 };
9194
9195 static const struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
9196         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9197         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9198         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9199         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9200         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9201         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9202         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9203         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9204         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9205         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9206         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9207         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9208         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9209         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9210         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9211         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9212         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9213         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9214         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9215         { } /* end */
9216 };
9217
9218 static const struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
9219         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9220         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9221         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9222         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9223         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
9224                               HDA_OUTPUT),
9225         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9226         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9227         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9228         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9229         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9230         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9231         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9232         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9233         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9234         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
9235         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9236         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9237         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT),
9238         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9239         { } /* end */
9240 };
9241
9242 static const struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
9243         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9244         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9245         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9246         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9247         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
9248                               HDA_OUTPUT),
9249         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9250         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9251         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9252         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9253         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
9254         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9255         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9256         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9257         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
9258         HDA_CODEC_VOLUME("Mic Boost Volume", 0x1b, 0, HDA_INPUT),
9259         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
9260         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9261         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT),
9262         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9263         { } /* end */
9264 };
9265
9266 static const struct snd_kcontrol_new alc883_fivestack_mixer[] = {
9267         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9268         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9269         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9270         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9271         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9272         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9273         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9274         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9275         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9276         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9277         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9278         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9279         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9280         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9281         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9282         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9283         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9284         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9285         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9286         { } /* end */
9287 };
9288
9289 static const struct snd_kcontrol_new alc883_targa_mixer[] = {
9290         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9291         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9292         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9293         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9294         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9295         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9296         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9297         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9298         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9299         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9300         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9301         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9302         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9303         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9304         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9305         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9306         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9307         { } /* end */
9308 };
9309
9310 static const struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
9311         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9312         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9313         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9314         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9315         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9316         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9317         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9318         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9319         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9320         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9321         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9322         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9323         { } /* end */
9324 };
9325
9326 static const struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
9327         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9328         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9329         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9330         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9331         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9332         { } /* end */
9333 };
9334
9335 static const struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
9336         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9337         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9338         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9339         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9340         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9341         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9342         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9343         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9344         { } /* end */
9345 };
9346
9347 static const struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
9348         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9349         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
9350         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9351         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9352         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9353         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9354         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9355         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9356         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9357         { } /* end */
9358 };
9359
9360 static const struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
9361         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9362         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9363         HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9364         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
9365         HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
9366         HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
9367         { } /* end */
9368 };
9369
9370 static const struct hda_verb alc883_medion_wim2160_verbs[] = {
9371         /* Unmute front mixer */
9372         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9373         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9374
9375         /* Set speaker pin to front mixer */
9376         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9377
9378         /* Init headphone pin */
9379         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9380         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9381         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9382         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9383
9384         { } /* end */
9385 };
9386
9387 /* toggle speaker-output according to the hp-jack state */
9388 static void alc883_medion_wim2160_setup(struct hda_codec *codec)
9389 {
9390         struct alc_spec *spec = codec->spec;
9391
9392         spec->autocfg.hp_pins[0] = 0x1a;
9393         spec->autocfg.speaker_pins[0] = 0x15;
9394         spec->automute = 1;
9395         spec->automute_mode = ALC_AUTOMUTE_AMP;
9396 }
9397
9398 static const struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
9399         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9400         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9401         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9402         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9403         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9404         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9405         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9406         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9407         { } /* end */
9408 };
9409
9410 static const struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
9411         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9412         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9413         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9414         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9415         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9416         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9417         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9418         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9419         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9420         { } /* end */
9421 };
9422
9423 static const struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
9424         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9425         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9426         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9427         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
9428         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
9429                                                 0x0d, 1, 0x0, HDA_OUTPUT),
9430         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
9431         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
9432         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
9433         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9434         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9435         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9436         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9437         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9438         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9439         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9440         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9441         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9442         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9443         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9444         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9445         { } /* end */
9446 };
9447
9448 static const struct snd_kcontrol_new alc889A_mb31_mixer[] = {
9449         /* Output mixers */
9450         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
9451         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
9452         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
9453         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
9454         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
9455                 HDA_OUTPUT),
9456         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
9457         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
9458         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
9459         /* Output switches */
9460         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
9461         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
9462         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
9463         /* Boost mixers */
9464         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT),
9465         HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT),
9466         /* Input mixers */
9467         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
9468         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
9469         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9470         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9471         { } /* end */
9472 };
9473
9474 static const struct snd_kcontrol_new alc883_vaiott_mixer[] = {
9475         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9476         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9477         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9478         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9479         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
9480         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9481         { } /* end */
9482 };
9483
9484 static const struct hda_bind_ctls alc883_bind_cap_vol = {
9485         .ops = &snd_hda_bind_vol,
9486         .values = {
9487                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9488                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9489                 0
9490         },
9491 };
9492
9493 static const struct hda_bind_ctls alc883_bind_cap_switch = {
9494         .ops = &snd_hda_bind_sw,
9495         .values = {
9496                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9497                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9498                 0
9499         },
9500 };
9501
9502 static const struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
9503         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9504         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9505         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9506         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9507         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9508         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9509         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9510         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9511         { } /* end */
9512 };
9513
9514 static const struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
9515         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
9516         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
9517         {
9518                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9519                 /* .name = "Capture Source", */
9520                 .name = "Input Source",
9521                 .count = 1,
9522                 .info = alc_mux_enum_info,
9523                 .get = alc_mux_enum_get,
9524                 .put = alc_mux_enum_put,
9525         },
9526         { } /* end */
9527 };
9528
9529 static const struct snd_kcontrol_new alc883_chmode_mixer[] = {
9530         {
9531                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9532                 .name = "Channel Mode",
9533                 .info = alc_ch_mode_info,
9534                 .get = alc_ch_mode_get,
9535                 .put = alc_ch_mode_put,
9536         },
9537         { } /* end */
9538 };
9539
9540 /* toggle speaker-output according to the hp-jack state */
9541 static void alc883_mitac_setup(struct hda_codec *codec)
9542 {
9543         struct alc_spec *spec = codec->spec;
9544
9545         spec->autocfg.hp_pins[0] = 0x15;
9546         spec->autocfg.speaker_pins[0] = 0x14;
9547         spec->autocfg.speaker_pins[1] = 0x17;
9548         spec->automute = 1;
9549         spec->automute_mode = ALC_AUTOMUTE_AMP;
9550 }
9551
9552 static const struct hda_verb alc883_mitac_verbs[] = {
9553         /* HP */
9554         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9555         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9556         /* Subwoofer */
9557         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9558         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9559
9560         /* enable unsolicited event */
9561         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9562         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
9563
9564         { } /* end */
9565 };
9566
9567 static const struct hda_verb alc883_clevo_m540r_verbs[] = {
9568         /* HP */
9569         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9570         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9571         /* Int speaker */
9572         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
9573
9574         /* enable unsolicited event */
9575         /*
9576         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9577         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9578         */
9579
9580         { } /* end */
9581 };
9582
9583 static const struct hda_verb alc883_clevo_m720_verbs[] = {
9584         /* HP */
9585         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9586         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9587         /* Int speaker */
9588         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
9589         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9590
9591         /* enable unsolicited event */
9592         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9593         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9594
9595         { } /* end */
9596 };
9597
9598 static const struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
9599         /* HP */
9600         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9601         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9602         /* Subwoofer */
9603         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9604         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9605
9606         /* enable unsolicited event */
9607         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9608
9609         { } /* end */
9610 };
9611
9612 static const struct hda_verb alc883_targa_verbs[] = {
9613         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9614         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9615
9616         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9617         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9618
9619 /* Connect Line-Out side jack (SPDIF) to Side */
9620         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9621         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9622         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
9623 /* Connect Mic jack to CLFE */
9624         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9625         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9626         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
9627 /* Connect Line-in jack to Surround */
9628         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9629         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9630         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
9631 /* Connect HP out jack to Front */
9632         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9633         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9634         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9635
9636         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9637
9638         { } /* end */
9639 };
9640
9641 static const struct hda_verb alc883_lenovo_101e_verbs[] = {
9642         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9643         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
9644         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
9645         { } /* end */
9646 };
9647
9648 static const struct hda_verb alc883_lenovo_nb0763_verbs[] = {
9649         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9650         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9651         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9652         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9653         { } /* end */
9654 };
9655
9656 static const struct hda_verb alc888_lenovo_ms7195_verbs[] = {
9657         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9658         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9659         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9660         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
9661         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
9662         { } /* end */
9663 };
9664
9665 static const struct hda_verb alc883_haier_w66_verbs[] = {
9666         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9667         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9668
9669         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9670
9671         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9672         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9673         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9674         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9675         { } /* end */
9676 };
9677
9678 static const struct hda_verb alc888_lenovo_sky_verbs[] = {
9679         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9680         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9681         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9682         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9683         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9684         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9685         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9686         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9687         { } /* end */
9688 };
9689
9690 static const struct hda_verb alc888_6st_dell_verbs[] = {
9691         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9692         { }
9693 };
9694
9695 static const struct hda_verb alc883_vaiott_verbs[] = {
9696         /* HP */
9697         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9698         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9699
9700         /* enable unsolicited event */
9701         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9702
9703         { } /* end */
9704 };
9705
9706 static void alc888_3st_hp_setup(struct hda_codec *codec)
9707 {
9708         struct alc_spec *spec = codec->spec;
9709
9710         spec->autocfg.hp_pins[0] = 0x1b;
9711         spec->autocfg.speaker_pins[0] = 0x14;
9712         spec->autocfg.speaker_pins[1] = 0x16;
9713         spec->autocfg.speaker_pins[2] = 0x18;
9714         spec->automute = 1;
9715         spec->automute_mode = ALC_AUTOMUTE_AMP;
9716 }
9717
9718 static const struct hda_verb alc888_3st_hp_verbs[] = {
9719         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
9720         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
9721         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
9722         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9723         { } /* end */
9724 };
9725
9726 /*
9727  * 2ch mode
9728  */
9729 static const struct hda_verb alc888_3st_hp_2ch_init[] = {
9730         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9731         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9732         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
9733         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9734         { } /* end */
9735 };
9736
9737 /*
9738  * 4ch mode
9739  */
9740 static const struct hda_verb alc888_3st_hp_4ch_init[] = {
9741         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9742         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9743         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9744         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9745         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9746         { } /* end */
9747 };
9748
9749 /*
9750  * 6ch mode
9751  */
9752 static const struct hda_verb alc888_3st_hp_6ch_init[] = {
9753         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9754         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9755         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
9756         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9757         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9758         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9759         { } /* end */
9760 };
9761
9762 static const struct hda_channel_mode alc888_3st_hp_modes[3] = {
9763         { 2, alc888_3st_hp_2ch_init },
9764         { 4, alc888_3st_hp_4ch_init },
9765         { 6, alc888_3st_hp_6ch_init },
9766 };
9767
9768 static void alc888_lenovo_ms7195_setup(struct hda_codec *codec)
9769 {
9770         struct alc_spec *spec = codec->spec;
9771
9772         spec->autocfg.hp_pins[0] = 0x1b;
9773         spec->autocfg.line_out_pins[0] = 0x14;
9774         spec->autocfg.speaker_pins[0] = 0x15;
9775         spec->automute = 1;
9776         spec->automute_mode = ALC_AUTOMUTE_AMP;
9777 }
9778
9779 /* toggle speaker-output according to the hp-jack state */
9780 static void alc883_lenovo_nb0763_setup(struct hda_codec *codec)
9781 {
9782         struct alc_spec *spec = codec->spec;
9783
9784         spec->autocfg.hp_pins[0] = 0x14;
9785         spec->autocfg.speaker_pins[0] = 0x15;
9786         spec->automute = 1;
9787         spec->automute_mode = ALC_AUTOMUTE_AMP;
9788 }
9789
9790 /* toggle speaker-output according to the hp-jack state */
9791 #define alc883_targa_init_hook          alc882_targa_init_hook
9792 #define alc883_targa_unsol_event        alc882_targa_unsol_event
9793
9794 static void alc883_clevo_m720_setup(struct hda_codec *codec)
9795 {
9796         struct alc_spec *spec = codec->spec;
9797
9798         spec->autocfg.hp_pins[0] = 0x15;
9799         spec->autocfg.speaker_pins[0] = 0x14;
9800         spec->automute = 1;
9801         spec->automute_mode = ALC_AUTOMUTE_AMP;
9802 }
9803
9804 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
9805 {
9806         alc_hp_automute(codec);
9807         alc88x_simple_mic_automute(codec);
9808 }
9809
9810 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
9811                                            unsigned int res)
9812 {
9813         switch (res >> 26) {
9814         case ALC880_MIC_EVENT:
9815                 alc88x_simple_mic_automute(codec);
9816                 break;
9817         default:
9818                 alc_sku_unsol_event(codec, res);
9819                 break;
9820         }
9821 }
9822
9823 /* toggle speaker-output according to the hp-jack state */
9824 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
9825 {
9826         struct alc_spec *spec = codec->spec;
9827
9828         spec->autocfg.hp_pins[0] = 0x14;
9829         spec->autocfg.speaker_pins[0] = 0x15;
9830         spec->automute = 1;
9831         spec->automute_mode = ALC_AUTOMUTE_AMP;
9832 }
9833
9834 static void alc883_haier_w66_setup(struct hda_codec *codec)
9835 {
9836         struct alc_spec *spec = codec->spec;
9837
9838         spec->autocfg.hp_pins[0] = 0x1b;
9839         spec->autocfg.speaker_pins[0] = 0x14;
9840         spec->automute = 1;
9841         spec->automute_mode = ALC_AUTOMUTE_AMP;
9842 }
9843
9844 static void alc883_lenovo_101e_setup(struct hda_codec *codec)
9845 {
9846         struct alc_spec *spec = codec->spec;
9847
9848         spec->autocfg.hp_pins[0] = 0x1b;
9849         spec->autocfg.line_out_pins[0] = 0x14;
9850         spec->autocfg.speaker_pins[0] = 0x15;
9851         spec->automute = 1;
9852         spec->detect_line = 1;
9853         spec->automute_lines = 1;
9854         spec->automute_mode = ALC_AUTOMUTE_AMP;
9855 }
9856
9857 /* toggle speaker-output according to the hp-jack state */
9858 static void alc883_acer_aspire_setup(struct hda_codec *codec)
9859 {
9860         struct alc_spec *spec = codec->spec;
9861
9862         spec->autocfg.hp_pins[0] = 0x14;
9863         spec->autocfg.speaker_pins[0] = 0x15;
9864         spec->autocfg.speaker_pins[1] = 0x16;
9865         spec->automute = 1;
9866         spec->automute_mode = ALC_AUTOMUTE_AMP;
9867 }
9868
9869 static const struct hda_verb alc883_acer_eapd_verbs[] = {
9870         /* HP Pin: output 0 (0x0c) */
9871         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9872         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9873         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9874         /* Front Pin: output 0 (0x0c) */
9875         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9876         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9877         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9878         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
9879         /* eanable EAPD on medion laptop */
9880         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9881         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9882         /* enable unsolicited event */
9883         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9884         { }
9885 };
9886
9887 static void alc888_6st_dell_setup(struct hda_codec *codec)
9888 {
9889         struct alc_spec *spec = codec->spec;
9890
9891         spec->autocfg.hp_pins[0] = 0x1b;
9892         spec->autocfg.speaker_pins[0] = 0x14;
9893         spec->autocfg.speaker_pins[1] = 0x15;
9894         spec->autocfg.speaker_pins[2] = 0x16;
9895         spec->autocfg.speaker_pins[3] = 0x17;
9896         spec->automute = 1;
9897         spec->automute_mode = ALC_AUTOMUTE_AMP;
9898 }
9899
9900 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9901 {
9902         struct alc_spec *spec = codec->spec;
9903
9904         spec->autocfg.hp_pins[0] = 0x1b;
9905         spec->autocfg.speaker_pins[0] = 0x14;
9906         spec->autocfg.speaker_pins[1] = 0x15;
9907         spec->autocfg.speaker_pins[2] = 0x16;
9908         spec->autocfg.speaker_pins[3] = 0x17;
9909         spec->autocfg.speaker_pins[4] = 0x1a;
9910         spec->automute = 1;
9911         spec->automute_mode = ALC_AUTOMUTE_AMP;
9912 }
9913
9914 static void alc883_vaiott_setup(struct hda_codec *codec)
9915 {
9916         struct alc_spec *spec = codec->spec;
9917
9918         spec->autocfg.hp_pins[0] = 0x15;
9919         spec->autocfg.speaker_pins[0] = 0x14;
9920         spec->autocfg.speaker_pins[1] = 0x17;
9921         spec->automute = 1;
9922         spec->automute_mode = ALC_AUTOMUTE_AMP;
9923 }
9924
9925 static const struct hda_verb alc888_asus_m90v_verbs[] = {
9926         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9927         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9928         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9929         /* enable unsolicited event */
9930         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9931         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9932         { } /* end */
9933 };
9934
9935 static void alc883_mode2_setup(struct hda_codec *codec)
9936 {
9937         struct alc_spec *spec = codec->spec;
9938
9939         spec->autocfg.hp_pins[0] = 0x1b;
9940         spec->autocfg.speaker_pins[0] = 0x14;
9941         spec->autocfg.speaker_pins[1] = 0x15;
9942         spec->autocfg.speaker_pins[2] = 0x16;
9943         spec->ext_mic.pin = 0x18;
9944         spec->int_mic.pin = 0x19;
9945         spec->ext_mic.mux_idx = 0;
9946         spec->int_mic.mux_idx = 1;
9947         spec->auto_mic = 1;
9948         spec->automute = 1;
9949         spec->automute_mode = ALC_AUTOMUTE_AMP;
9950 }
9951
9952 static const struct hda_verb alc888_asus_eee1601_verbs[] = {
9953         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9954         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9955         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9956         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9957         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9958         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9959         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9960         /* enable unsolicited event */
9961         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9962         { } /* end */
9963 };
9964
9965 static void alc883_eee1601_inithook(struct hda_codec *codec)
9966 {
9967         struct alc_spec *spec = codec->spec;
9968
9969         spec->autocfg.hp_pins[0] = 0x14;
9970         spec->autocfg.speaker_pins[0] = 0x1b;
9971         alc_hp_automute(codec);
9972 }
9973
9974 static const struct hda_verb alc889A_mb31_verbs[] = {
9975         /* Init rear pin (used as headphone output) */
9976         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9977         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9978         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9979         /* Init line pin (used as output in 4ch and 6ch mode) */
9980         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9981         /* Init line 2 pin (used as headphone out by default) */
9982         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9983         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9984         { } /* end */
9985 };
9986
9987 /* Mute speakers according to the headphone jack state */
9988 static void alc889A_mb31_automute(struct hda_codec *codec)
9989 {
9990         unsigned int present;
9991
9992         /* Mute only in 2ch or 4ch mode */
9993         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9994             == 0x00) {
9995                 present = snd_hda_jack_detect(codec, 0x15);
9996                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9997                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9998                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9999                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
10000         }
10001 }
10002
10003 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
10004 {
10005         if ((res >> 26) == ALC880_HP_EVENT)
10006                 alc889A_mb31_automute(codec);
10007 }
10008
10009
10010 #ifdef CONFIG_SND_HDA_POWER_SAVE
10011 #define alc882_loopbacks        alc880_loopbacks
10012 #endif
10013
10014 /* pcm configuration: identical with ALC880 */
10015 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
10016 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
10017 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
10018 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
10019
10020 static const hda_nid_t alc883_slave_dig_outs[] = {
10021         ALC1200_DIGOUT_NID, 0,
10022 };
10023
10024 static const hda_nid_t alc1200_slave_dig_outs[] = {
10025         ALC883_DIGOUT_NID, 0,
10026 };
10027
10028 /*
10029  * configuration and preset
10030  */
10031 static const char * const alc882_models[ALC882_MODEL_LAST] = {
10032         [ALC882_3ST_DIG]        = "3stack-dig",
10033         [ALC882_6ST_DIG]        = "6stack-dig",
10034         [ALC882_ARIMA]          = "arima",
10035         [ALC882_W2JC]           = "w2jc",
10036         [ALC882_TARGA]          = "targa",
10037         [ALC882_ASUS_A7J]       = "asus-a7j",
10038         [ALC882_ASUS_A7M]       = "asus-a7m",
10039         [ALC885_MACPRO]         = "macpro",
10040         [ALC885_MB5]            = "mb5",
10041         [ALC885_MACMINI3]       = "macmini3",
10042         [ALC885_MBA21]          = "mba21",
10043         [ALC885_MBP3]           = "mbp3",
10044         [ALC885_IMAC24]         = "imac24",
10045         [ALC885_IMAC91]         = "imac91",
10046         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
10047         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
10048         [ALC883_3ST_6ch]        = "3stack-6ch",
10049         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
10050         [ALC883_TARGA_DIG]      = "targa-dig",
10051         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
10052         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
10053         [ALC883_ACER]           = "acer",
10054         [ALC883_ACER_ASPIRE]    = "acer-aspire",
10055         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
10056         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
10057         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
10058         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
10059         [ALC883_MEDION]         = "medion",
10060         [ALC883_MEDION_WIM2160] = "medion-wim2160",
10061         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
10062         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
10063         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
10064         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
10065         [ALC888_LENOVO_SKY] = "lenovo-sky",
10066         [ALC883_HAIER_W66]      = "haier-w66",
10067         [ALC888_3ST_HP]         = "3stack-hp",
10068         [ALC888_6ST_DELL]       = "6stack-dell",
10069         [ALC883_MITAC]          = "mitac",
10070         [ALC883_CLEVO_M540R]    = "clevo-m540r",
10071         [ALC883_CLEVO_M720]     = "clevo-m720",
10072         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
10073         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
10074         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
10075         [ALC889A_INTEL]         = "intel-alc889a",
10076         [ALC889_INTEL]          = "intel-x58",
10077         [ALC1200_ASUS_P5Q]      = "asus-p5q",
10078         [ALC889A_MB31]          = "mb31",
10079         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
10080         [ALC882_AUTO]           = "auto",
10081 };
10082
10083 static const struct snd_pci_quirk alc882_cfg_tbl[] = {
10084         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
10085
10086         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
10087         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
10088         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
10089         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
10090         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
10091         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
10092         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
10093                 ALC888_ACER_ASPIRE_4930G),
10094         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
10095                 ALC888_ACER_ASPIRE_4930G),
10096         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
10097                 ALC888_ACER_ASPIRE_8930G),
10098         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
10099                 ALC888_ACER_ASPIRE_8930G),
10100         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
10101         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
10102         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
10103                 ALC888_ACER_ASPIRE_6530G),
10104         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
10105                 ALC888_ACER_ASPIRE_6530G),
10106         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
10107                 ALC888_ACER_ASPIRE_7730G),
10108         /* default Acer -- disabled as it causes more problems.
10109          *    model=auto should work fine now
10110          */
10111         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
10112
10113         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
10114
10115         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavilion", ALC883_6ST_DIG),
10116         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
10117         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
10118         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
10119         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
10120         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
10121
10122         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
10123         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
10124         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
10125         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
10126         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
10127         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
10128         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
10129         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
10130         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
10131         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
10132         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
10133
10134         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
10135         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
10136         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
10137         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
10138         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
10139         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
10140         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
10141         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
10142         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
10143
10144         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
10145         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
10146         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
10147         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
10148         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
10149         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
10150         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
10151         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
10152         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
10153         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
10154         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
10155         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
10156         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
10157         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
10158         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
10159         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
10160         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
10161         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
10162         SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
10163         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
10164         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
10165         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
10166         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
10167         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
10168         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
10169         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
10170         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
10171         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
10172         SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
10173         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
10174         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
10175
10176         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
10177         SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG),
10178         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
10179         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
10180         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
10181         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
10182         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
10183         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
10184         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
10185         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
10186                       ALC883_FUJITSU_PI2515),
10187         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
10188                 ALC888_FUJITSU_XA3530),
10189         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
10190         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
10191         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
10192         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
10193         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
10194         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
10195         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
10196         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
10197
10198         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
10199         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
10200         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
10201         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
10202         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
10203         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
10204         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
10205
10206         {}
10207 };
10208
10209 /* codec SSID table for Intel Mac */
10210 static const struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
10211         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
10212         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
10213         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
10214         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
10215         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
10216         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
10217         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
10218         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31),
10219         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M),
10220         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3),
10221         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21),
10222         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
10223         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
10224         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
10225         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
10226         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
10227         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5),
10228         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
10229          * so apparently no perfect solution yet
10230          */
10231         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
10232         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
10233         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
10234         {} /* terminator */
10235 };
10236
10237 static const struct alc_config_preset alc882_presets[] = {
10238         [ALC882_3ST_DIG] = {
10239                 .mixers = { alc882_base_mixer },
10240                 .init_verbs = { alc882_base_init_verbs,
10241                                 alc882_adc1_init_verbs },
10242                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10243                 .dac_nids = alc882_dac_nids,
10244                 .dig_out_nid = ALC882_DIGOUT_NID,
10245                 .dig_in_nid = ALC882_DIGIN_NID,
10246                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10247                 .channel_mode = alc882_ch_modes,
10248                 .need_dac_fix = 1,
10249                 .input_mux = &alc882_capture_source,
10250         },
10251         [ALC882_6ST_DIG] = {
10252                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
10253                 .init_verbs = { alc882_base_init_verbs,
10254                                 alc882_adc1_init_verbs },
10255                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10256                 .dac_nids = alc882_dac_nids,
10257                 .dig_out_nid = ALC882_DIGOUT_NID,
10258                 .dig_in_nid = ALC882_DIGIN_NID,
10259                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
10260                 .channel_mode = alc882_sixstack_modes,
10261                 .input_mux = &alc882_capture_source,
10262         },
10263         [ALC882_ARIMA] = {
10264                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
10265                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10266                                 alc882_eapd_verbs },
10267                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10268                 .dac_nids = alc882_dac_nids,
10269                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
10270                 .channel_mode = alc882_sixstack_modes,
10271                 .input_mux = &alc882_capture_source,
10272         },
10273         [ALC882_W2JC] = {
10274                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
10275                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10276                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
10277                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10278                 .dac_nids = alc882_dac_nids,
10279                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10280                 .channel_mode = alc880_threestack_modes,
10281                 .need_dac_fix = 1,
10282                 .input_mux = &alc882_capture_source,
10283                 .dig_out_nid = ALC882_DIGOUT_NID,
10284         },
10285            [ALC885_MBA21] = {
10286                         .mixers = { alc885_mba21_mixer },
10287                         .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
10288                         .num_dacs = 2,
10289                         .dac_nids = alc882_dac_nids,
10290                         .channel_mode = alc885_mba21_ch_modes,
10291                         .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10292                         .input_mux = &alc882_capture_source,
10293                         .unsol_event = alc_sku_unsol_event,
10294                         .setup = alc885_mba21_setup,
10295                         .init_hook = alc_hp_automute,
10296        },
10297         [ALC885_MBP3] = {
10298                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
10299                 .init_verbs = { alc885_mbp3_init_verbs,
10300                                 alc880_gpio1_init_verbs },
10301                 .num_dacs = 2,
10302                 .dac_nids = alc882_dac_nids,
10303                 .hp_nid = 0x04,
10304                 .channel_mode = alc885_mbp_4ch_modes,
10305                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
10306                 .input_mux = &alc882_capture_source,
10307                 .dig_out_nid = ALC882_DIGOUT_NID,
10308                 .dig_in_nid = ALC882_DIGIN_NID,
10309                 .unsol_event = alc_sku_unsol_event,
10310                 .setup = alc885_mbp3_setup,
10311                 .init_hook = alc_hp_automute,
10312         },
10313         [ALC885_MB5] = {
10314                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
10315                 .init_verbs = { alc885_mb5_init_verbs,
10316                                 alc880_gpio1_init_verbs },
10317                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10318                 .dac_nids = alc882_dac_nids,
10319                 .channel_mode = alc885_mb5_6ch_modes,
10320                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
10321                 .input_mux = &mb5_capture_source,
10322                 .dig_out_nid = ALC882_DIGOUT_NID,
10323                 .dig_in_nid = ALC882_DIGIN_NID,
10324                 .unsol_event = alc_sku_unsol_event,
10325                 .setup = alc885_mb5_setup,
10326                 .init_hook = alc_hp_automute,
10327         },
10328         [ALC885_MACMINI3] = {
10329                 .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
10330                 .init_verbs = { alc885_macmini3_init_verbs,
10331                                 alc880_gpio1_init_verbs },
10332                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10333                 .dac_nids = alc882_dac_nids,
10334                 .channel_mode = alc885_macmini3_6ch_modes,
10335                 .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
10336                 .input_mux = &macmini3_capture_source,
10337                 .dig_out_nid = ALC882_DIGOUT_NID,
10338                 .dig_in_nid = ALC882_DIGIN_NID,
10339                 .unsol_event = alc_sku_unsol_event,
10340                 .setup = alc885_macmini3_setup,
10341                 .init_hook = alc_hp_automute,
10342         },
10343         [ALC885_MACPRO] = {
10344                 .mixers = { alc882_macpro_mixer },
10345                 .init_verbs = { alc882_macpro_init_verbs },
10346                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10347                 .dac_nids = alc882_dac_nids,
10348                 .dig_out_nid = ALC882_DIGOUT_NID,
10349                 .dig_in_nid = ALC882_DIGIN_NID,
10350                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10351                 .channel_mode = alc882_ch_modes,
10352                 .input_mux = &alc882_capture_source,
10353                 .init_hook = alc885_macpro_init_hook,
10354         },
10355         [ALC885_IMAC24] = {
10356                 .mixers = { alc885_imac24_mixer },
10357                 .init_verbs = { alc885_imac24_init_verbs },
10358                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10359                 .dac_nids = alc882_dac_nids,
10360                 .dig_out_nid = ALC882_DIGOUT_NID,
10361                 .dig_in_nid = ALC882_DIGIN_NID,
10362                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10363                 .channel_mode = alc882_ch_modes,
10364                 .input_mux = &alc882_capture_source,
10365                 .unsol_event = alc_sku_unsol_event,
10366                 .setup = alc885_imac24_setup,
10367                 .init_hook = alc885_imac24_init_hook,
10368         },
10369         [ALC885_IMAC91] = {
10370                 .mixers = {alc885_imac91_mixer},
10371                 .init_verbs = { alc885_imac91_init_verbs,
10372                                 alc880_gpio1_init_verbs },
10373                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10374                 .dac_nids = alc882_dac_nids,
10375                 .channel_mode = alc885_mba21_ch_modes,
10376                 .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10377                 .input_mux = &alc889A_imac91_capture_source,
10378                 .dig_out_nid = ALC882_DIGOUT_NID,
10379                 .dig_in_nid = ALC882_DIGIN_NID,
10380                 .unsol_event = alc_sku_unsol_event,
10381                 .setup = alc885_imac91_setup,
10382                 .init_hook = alc_hp_automute,
10383         },
10384         [ALC882_TARGA] = {
10385                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
10386                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10387                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
10388                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10389                 .dac_nids = alc882_dac_nids,
10390                 .dig_out_nid = ALC882_DIGOUT_NID,
10391                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10392                 .adc_nids = alc882_adc_nids,
10393                 .capsrc_nids = alc882_capsrc_nids,
10394                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10395                 .channel_mode = alc882_3ST_6ch_modes,
10396                 .need_dac_fix = 1,
10397                 .input_mux = &alc882_capture_source,
10398                 .unsol_event = alc_sku_unsol_event,
10399                 .setup = alc882_targa_setup,
10400                 .init_hook = alc882_targa_automute,
10401         },
10402         [ALC882_ASUS_A7J] = {
10403                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
10404                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10405                                 alc882_asus_a7j_verbs},
10406                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10407                 .dac_nids = alc882_dac_nids,
10408                 .dig_out_nid = ALC882_DIGOUT_NID,
10409                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10410                 .adc_nids = alc882_adc_nids,
10411                 .capsrc_nids = alc882_capsrc_nids,
10412                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10413                 .channel_mode = alc882_3ST_6ch_modes,
10414                 .need_dac_fix = 1,
10415                 .input_mux = &alc882_capture_source,
10416         },
10417         [ALC882_ASUS_A7M] = {
10418                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
10419                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10420                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
10421                                 alc882_asus_a7m_verbs },
10422                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10423                 .dac_nids = alc882_dac_nids,
10424                 .dig_out_nid = ALC882_DIGOUT_NID,
10425                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10426                 .channel_mode = alc880_threestack_modes,
10427                 .need_dac_fix = 1,
10428                 .input_mux = &alc882_capture_source,
10429         },
10430         [ALC883_3ST_2ch_DIG] = {
10431                 .mixers = { alc883_3ST_2ch_mixer },
10432                 .init_verbs = { alc883_init_verbs },
10433                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10434                 .dac_nids = alc883_dac_nids,
10435                 .dig_out_nid = ALC883_DIGOUT_NID,
10436                 .dig_in_nid = ALC883_DIGIN_NID,
10437                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10438                 .channel_mode = alc883_3ST_2ch_modes,
10439                 .input_mux = &alc883_capture_source,
10440         },
10441         [ALC883_3ST_6ch_DIG] = {
10442                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10443                 .init_verbs = { alc883_init_verbs },
10444                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10445                 .dac_nids = alc883_dac_nids,
10446                 .dig_out_nid = ALC883_DIGOUT_NID,
10447                 .dig_in_nid = ALC883_DIGIN_NID,
10448                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10449                 .channel_mode = alc883_3ST_6ch_modes,
10450                 .need_dac_fix = 1,
10451                 .input_mux = &alc883_capture_source,
10452         },
10453         [ALC883_3ST_6ch] = {
10454                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10455                 .init_verbs = { alc883_init_verbs },
10456                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10457                 .dac_nids = alc883_dac_nids,
10458                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10459                 .channel_mode = alc883_3ST_6ch_modes,
10460                 .need_dac_fix = 1,
10461                 .input_mux = &alc883_capture_source,
10462         },
10463         [ALC883_3ST_6ch_INTEL] = {
10464                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
10465                 .init_verbs = { alc883_init_verbs },
10466                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10467                 .dac_nids = alc883_dac_nids,
10468                 .dig_out_nid = ALC883_DIGOUT_NID,
10469                 .dig_in_nid = ALC883_DIGIN_NID,
10470                 .slave_dig_outs = alc883_slave_dig_outs,
10471                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
10472                 .channel_mode = alc883_3ST_6ch_intel_modes,
10473                 .need_dac_fix = 1,
10474                 .input_mux = &alc883_3stack_6ch_intel,
10475         },
10476         [ALC889A_INTEL] = {
10477                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10478                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
10479                                 alc_hp15_unsol_verbs },
10480                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10481                 .dac_nids = alc883_dac_nids,
10482                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10483                 .adc_nids = alc889_adc_nids,
10484                 .dig_out_nid = ALC883_DIGOUT_NID,
10485                 .dig_in_nid = ALC883_DIGIN_NID,
10486                 .slave_dig_outs = alc883_slave_dig_outs,
10487                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10488                 .channel_mode = alc889_8ch_intel_modes,
10489                 .capsrc_nids = alc889_capsrc_nids,
10490                 .input_mux = &alc889_capture_source,
10491                 .setup = alc889_automute_setup,
10492                 .init_hook = alc_hp_automute,
10493                 .unsol_event = alc_sku_unsol_event,
10494                 .need_dac_fix = 1,
10495         },
10496         [ALC889_INTEL] = {
10497                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10498                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
10499                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
10500                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10501                 .dac_nids = alc883_dac_nids,
10502                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10503                 .adc_nids = alc889_adc_nids,
10504                 .dig_out_nid = ALC883_DIGOUT_NID,
10505                 .dig_in_nid = ALC883_DIGIN_NID,
10506                 .slave_dig_outs = alc883_slave_dig_outs,
10507                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10508                 .channel_mode = alc889_8ch_intel_modes,
10509                 .capsrc_nids = alc889_capsrc_nids,
10510                 .input_mux = &alc889_capture_source,
10511                 .setup = alc889_automute_setup,
10512                 .init_hook = alc889_intel_init_hook,
10513                 .unsol_event = alc_sku_unsol_event,
10514                 .need_dac_fix = 1,
10515         },
10516         [ALC883_6ST_DIG] = {
10517                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10518                 .init_verbs = { alc883_init_verbs },
10519                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10520                 .dac_nids = alc883_dac_nids,
10521                 .dig_out_nid = ALC883_DIGOUT_NID,
10522                 .dig_in_nid = ALC883_DIGIN_NID,
10523                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10524                 .channel_mode = alc883_sixstack_modes,
10525                 .input_mux = &alc883_capture_source,
10526         },
10527         [ALC883_TARGA_DIG] = {
10528                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
10529                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10530                                 alc883_targa_verbs},
10531                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10532                 .dac_nids = alc883_dac_nids,
10533                 .dig_out_nid = ALC883_DIGOUT_NID,
10534                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10535                 .channel_mode = alc883_3ST_6ch_modes,
10536                 .need_dac_fix = 1,
10537                 .input_mux = &alc883_capture_source,
10538                 .unsol_event = alc883_targa_unsol_event,
10539                 .setup = alc882_targa_setup,
10540                 .init_hook = alc882_targa_automute,
10541         },
10542         [ALC883_TARGA_2ch_DIG] = {
10543                 .mixers = { alc883_targa_2ch_mixer},
10544                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10545                                 alc883_targa_verbs},
10546                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10547                 .dac_nids = alc883_dac_nids,
10548                 .adc_nids = alc883_adc_nids_alt,
10549                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10550                 .capsrc_nids = alc883_capsrc_nids,
10551                 .dig_out_nid = ALC883_DIGOUT_NID,
10552                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10553                 .channel_mode = alc883_3ST_2ch_modes,
10554                 .input_mux = &alc883_capture_source,
10555                 .unsol_event = alc883_targa_unsol_event,
10556                 .setup = alc882_targa_setup,
10557                 .init_hook = alc882_targa_automute,
10558         },
10559         [ALC883_TARGA_8ch_DIG] = {
10560                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
10561                             alc883_chmode_mixer },
10562                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10563                                 alc883_targa_verbs },
10564                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10565                 .dac_nids = alc883_dac_nids,
10566                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10567                 .adc_nids = alc883_adc_nids_rev,
10568                 .capsrc_nids = alc883_capsrc_nids_rev,
10569                 .dig_out_nid = ALC883_DIGOUT_NID,
10570                 .dig_in_nid = ALC883_DIGIN_NID,
10571                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
10572                 .channel_mode = alc883_4ST_8ch_modes,
10573                 .need_dac_fix = 1,
10574                 .input_mux = &alc883_capture_source,
10575                 .unsol_event = alc883_targa_unsol_event,
10576                 .setup = alc882_targa_setup,
10577                 .init_hook = alc882_targa_automute,
10578         },
10579         [ALC883_ACER] = {
10580                 .mixers = { alc883_base_mixer },
10581                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
10582                  * and the headphone jack.  Turn this on and rely on the
10583                  * standard mute methods whenever the user wants to turn
10584                  * these outputs off.
10585                  */
10586                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
10587                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10588                 .dac_nids = alc883_dac_nids,
10589                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10590                 .channel_mode = alc883_3ST_2ch_modes,
10591                 .input_mux = &alc883_capture_source,
10592         },
10593         [ALC883_ACER_ASPIRE] = {
10594                 .mixers = { alc883_acer_aspire_mixer },
10595                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
10596                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10597                 .dac_nids = alc883_dac_nids,
10598                 .dig_out_nid = ALC883_DIGOUT_NID,
10599                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10600                 .channel_mode = alc883_3ST_2ch_modes,
10601                 .input_mux = &alc883_capture_source,
10602                 .unsol_event = alc_sku_unsol_event,
10603                 .setup = alc883_acer_aspire_setup,
10604                 .init_hook = alc_hp_automute,
10605         },
10606         [ALC888_ACER_ASPIRE_4930G] = {
10607                 .mixers = { alc888_acer_aspire_4930g_mixer,
10608                                 alc883_chmode_mixer },
10609                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10610                                 alc888_acer_aspire_4930g_verbs },
10611                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10612                 .dac_nids = alc883_dac_nids,
10613                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10614                 .adc_nids = alc883_adc_nids_rev,
10615                 .capsrc_nids = alc883_capsrc_nids_rev,
10616                 .dig_out_nid = ALC883_DIGOUT_NID,
10617                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10618                 .channel_mode = alc883_3ST_6ch_modes,
10619                 .need_dac_fix = 1,
10620                 .const_channel_count = 6,
10621                 .num_mux_defs =
10622                         ARRAY_SIZE(alc888_2_capture_sources),
10623                 .input_mux = alc888_2_capture_sources,
10624                 .unsol_event = alc_sku_unsol_event,
10625                 .setup = alc888_acer_aspire_4930g_setup,
10626                 .init_hook = alc_hp_automute,
10627         },
10628         [ALC888_ACER_ASPIRE_6530G] = {
10629                 .mixers = { alc888_acer_aspire_6530_mixer },
10630                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10631                                 alc888_acer_aspire_6530g_verbs },
10632                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10633                 .dac_nids = alc883_dac_nids,
10634                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10635                 .adc_nids = alc883_adc_nids_rev,
10636                 .capsrc_nids = alc883_capsrc_nids_rev,
10637                 .dig_out_nid = ALC883_DIGOUT_NID,
10638                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10639                 .channel_mode = alc883_3ST_2ch_modes,
10640                 .num_mux_defs =
10641                         ARRAY_SIZE(alc888_2_capture_sources),
10642                 .input_mux = alc888_acer_aspire_6530_sources,
10643                 .unsol_event = alc_sku_unsol_event,
10644                 .setup = alc888_acer_aspire_6530g_setup,
10645                 .init_hook = alc_hp_automute,
10646         },
10647         [ALC888_ACER_ASPIRE_8930G] = {
10648                 .mixers = { alc889_acer_aspire_8930g_mixer,
10649                                 alc883_chmode_mixer },
10650                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10651                                 alc889_acer_aspire_8930g_verbs,
10652                                 alc889_eapd_verbs},
10653                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10654                 .dac_nids = alc883_dac_nids,
10655                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10656                 .adc_nids = alc889_adc_nids,
10657                 .capsrc_nids = alc889_capsrc_nids,
10658                 .dig_out_nid = ALC883_DIGOUT_NID,
10659                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10660                 .channel_mode = alc883_3ST_6ch_modes,
10661                 .need_dac_fix = 1,
10662                 .const_channel_count = 6,
10663                 .num_mux_defs =
10664                         ARRAY_SIZE(alc889_capture_sources),
10665                 .input_mux = alc889_capture_sources,
10666                 .unsol_event = alc_sku_unsol_event,
10667                 .setup = alc889_acer_aspire_8930g_setup,
10668                 .init_hook = alc_hp_automute,
10669 #ifdef CONFIG_SND_HDA_POWER_SAVE
10670                 .power_hook = alc_power_eapd,
10671 #endif
10672         },
10673         [ALC888_ACER_ASPIRE_7730G] = {
10674                 .mixers = { alc883_3ST_6ch_mixer,
10675                                 alc883_chmode_mixer },
10676                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10677                                 alc888_acer_aspire_7730G_verbs },
10678                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10679                 .dac_nids = alc883_dac_nids,
10680                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10681                 .adc_nids = alc883_adc_nids_rev,
10682                 .capsrc_nids = alc883_capsrc_nids_rev,
10683                 .dig_out_nid = ALC883_DIGOUT_NID,
10684                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10685                 .channel_mode = alc883_3ST_6ch_modes,
10686                 .need_dac_fix = 1,
10687                 .const_channel_count = 6,
10688                 .input_mux = &alc883_capture_source,
10689                 .unsol_event = alc_sku_unsol_event,
10690                 .setup = alc888_acer_aspire_7730g_setup,
10691                 .init_hook = alc_hp_automute,
10692         },
10693         [ALC883_MEDION] = {
10694                 .mixers = { alc883_fivestack_mixer,
10695                             alc883_chmode_mixer },
10696                 .init_verbs = { alc883_init_verbs,
10697                                 alc883_medion_eapd_verbs },
10698                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10699                 .dac_nids = alc883_dac_nids,
10700                 .adc_nids = alc883_adc_nids_alt,
10701                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10702                 .capsrc_nids = alc883_capsrc_nids,
10703                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10704                 .channel_mode = alc883_sixstack_modes,
10705                 .input_mux = &alc883_capture_source,
10706         },
10707         [ALC883_MEDION_WIM2160] = {
10708                 .mixers = { alc883_medion_wim2160_mixer },
10709                 .init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
10710                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10711                 .dac_nids = alc883_dac_nids,
10712                 .dig_out_nid = ALC883_DIGOUT_NID,
10713                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10714                 .adc_nids = alc883_adc_nids,
10715                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10716                 .channel_mode = alc883_3ST_2ch_modes,
10717                 .input_mux = &alc883_capture_source,
10718                 .unsol_event = alc_sku_unsol_event,
10719                 .setup = alc883_medion_wim2160_setup,
10720                 .init_hook = alc_hp_automute,
10721         },
10722         [ALC883_LAPTOP_EAPD] = {
10723                 .mixers = { alc883_base_mixer },
10724                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
10725                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10726                 .dac_nids = alc883_dac_nids,
10727                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10728                 .channel_mode = alc883_3ST_2ch_modes,
10729                 .input_mux = &alc883_capture_source,
10730         },
10731         [ALC883_CLEVO_M540R] = {
10732                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10733                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
10734                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10735                 .dac_nids = alc883_dac_nids,
10736                 .dig_out_nid = ALC883_DIGOUT_NID,
10737                 .dig_in_nid = ALC883_DIGIN_NID,
10738                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
10739                 .channel_mode = alc883_3ST_6ch_clevo_modes,
10740                 .need_dac_fix = 1,
10741                 .input_mux = &alc883_capture_source,
10742                 /* This machine has the hardware HP auto-muting, thus
10743                  * we need no software mute via unsol event
10744                  */
10745         },
10746         [ALC883_CLEVO_M720] = {
10747                 .mixers = { alc883_clevo_m720_mixer },
10748                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
10749                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10750                 .dac_nids = alc883_dac_nids,
10751                 .dig_out_nid = ALC883_DIGOUT_NID,
10752                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10753                 .channel_mode = alc883_3ST_2ch_modes,
10754                 .input_mux = &alc883_capture_source,
10755                 .unsol_event = alc883_clevo_m720_unsol_event,
10756                 .setup = alc883_clevo_m720_setup,
10757                 .init_hook = alc883_clevo_m720_init_hook,
10758         },
10759         [ALC883_LENOVO_101E_2ch] = {
10760                 .mixers = { alc883_lenovo_101e_2ch_mixer},
10761                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
10762                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10763                 .dac_nids = alc883_dac_nids,
10764                 .adc_nids = alc883_adc_nids_alt,
10765                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10766                 .capsrc_nids = alc883_capsrc_nids,
10767                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10768                 .channel_mode = alc883_3ST_2ch_modes,
10769                 .input_mux = &alc883_lenovo_101e_capture_source,
10770                 .setup = alc883_lenovo_101e_setup,
10771                 .unsol_event = alc_sku_unsol_event,
10772                 .init_hook = alc_inithook,
10773         },
10774         [ALC883_LENOVO_NB0763] = {
10775                 .mixers = { alc883_lenovo_nb0763_mixer },
10776                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
10777                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10778                 .dac_nids = alc883_dac_nids,
10779                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10780                 .channel_mode = alc883_3ST_2ch_modes,
10781                 .need_dac_fix = 1,
10782                 .input_mux = &alc883_lenovo_nb0763_capture_source,
10783                 .unsol_event = alc_sku_unsol_event,
10784                 .setup = alc883_lenovo_nb0763_setup,
10785                 .init_hook = alc_hp_automute,
10786         },
10787         [ALC888_LENOVO_MS7195_DIG] = {
10788                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10789                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
10790                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10791                 .dac_nids = alc883_dac_nids,
10792                 .dig_out_nid = ALC883_DIGOUT_NID,
10793                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10794                 .channel_mode = alc883_3ST_6ch_modes,
10795                 .need_dac_fix = 1,
10796                 .input_mux = &alc883_capture_source,
10797                 .unsol_event = alc_sku_unsol_event,
10798                 .setup = alc888_lenovo_ms7195_setup,
10799                 .init_hook = alc_inithook,
10800         },
10801         [ALC883_HAIER_W66] = {
10802                 .mixers = { alc883_targa_2ch_mixer},
10803                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
10804                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10805                 .dac_nids = alc883_dac_nids,
10806                 .dig_out_nid = ALC883_DIGOUT_NID,
10807                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10808                 .channel_mode = alc883_3ST_2ch_modes,
10809                 .input_mux = &alc883_capture_source,
10810                 .unsol_event = alc_sku_unsol_event,
10811                 .setup = alc883_haier_w66_setup,
10812                 .init_hook = alc_hp_automute,
10813         },
10814         [ALC888_3ST_HP] = {
10815                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10816                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
10817                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10818                 .dac_nids = alc883_dac_nids,
10819                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
10820                 .channel_mode = alc888_3st_hp_modes,
10821                 .need_dac_fix = 1,
10822                 .input_mux = &alc883_capture_source,
10823                 .unsol_event = alc_sku_unsol_event,
10824                 .setup = alc888_3st_hp_setup,
10825                 .init_hook = alc_hp_automute,
10826         },
10827         [ALC888_6ST_DELL] = {
10828                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10829                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
10830                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10831                 .dac_nids = alc883_dac_nids,
10832                 .dig_out_nid = ALC883_DIGOUT_NID,
10833                 .dig_in_nid = ALC883_DIGIN_NID,
10834                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10835                 .channel_mode = alc883_sixstack_modes,
10836                 .input_mux = &alc883_capture_source,
10837                 .unsol_event = alc_sku_unsol_event,
10838                 .setup = alc888_6st_dell_setup,
10839                 .init_hook = alc_hp_automute,
10840         },
10841         [ALC883_MITAC] = {
10842                 .mixers = { alc883_mitac_mixer },
10843                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
10844                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10845                 .dac_nids = alc883_dac_nids,
10846                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10847                 .channel_mode = alc883_3ST_2ch_modes,
10848                 .input_mux = &alc883_capture_source,
10849                 .unsol_event = alc_sku_unsol_event,
10850                 .setup = alc883_mitac_setup,
10851                 .init_hook = alc_hp_automute,
10852         },
10853         [ALC883_FUJITSU_PI2515] = {
10854                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
10855                 .init_verbs = { alc883_init_verbs,
10856                                 alc883_2ch_fujitsu_pi2515_verbs},
10857                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10858                 .dac_nids = alc883_dac_nids,
10859                 .dig_out_nid = ALC883_DIGOUT_NID,
10860                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10861                 .channel_mode = alc883_3ST_2ch_modes,
10862                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10863                 .unsol_event = alc_sku_unsol_event,
10864                 .setup = alc883_2ch_fujitsu_pi2515_setup,
10865                 .init_hook = alc_hp_automute,
10866         },
10867         [ALC888_FUJITSU_XA3530] = {
10868                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
10869                 .init_verbs = { alc883_init_verbs,
10870                         alc888_fujitsu_xa3530_verbs },
10871                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10872                 .dac_nids = alc883_dac_nids,
10873                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10874                 .adc_nids = alc883_adc_nids_rev,
10875                 .capsrc_nids = alc883_capsrc_nids_rev,
10876                 .dig_out_nid = ALC883_DIGOUT_NID,
10877                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
10878                 .channel_mode = alc888_4ST_8ch_intel_modes,
10879                 .num_mux_defs =
10880                         ARRAY_SIZE(alc888_2_capture_sources),
10881                 .input_mux = alc888_2_capture_sources,
10882                 .unsol_event = alc_sku_unsol_event,
10883                 .setup = alc888_fujitsu_xa3530_setup,
10884                 .init_hook = alc_hp_automute,
10885         },
10886         [ALC888_LENOVO_SKY] = {
10887                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
10888                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
10889                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10890                 .dac_nids = alc883_dac_nids,
10891                 .dig_out_nid = ALC883_DIGOUT_NID,
10892                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10893                 .channel_mode = alc883_sixstack_modes,
10894                 .need_dac_fix = 1,
10895                 .input_mux = &alc883_lenovo_sky_capture_source,
10896                 .unsol_event = alc_sku_unsol_event,
10897                 .setup = alc888_lenovo_sky_setup,
10898                 .init_hook = alc_hp_automute,
10899         },
10900         [ALC888_ASUS_M90V] = {
10901                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10902                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10903                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10904                 .dac_nids = alc883_dac_nids,
10905                 .dig_out_nid = ALC883_DIGOUT_NID,
10906                 .dig_in_nid = ALC883_DIGIN_NID,
10907                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10908                 .channel_mode = alc883_3ST_6ch_modes,
10909                 .need_dac_fix = 1,
10910                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10911                 .unsol_event = alc_sku_unsol_event,
10912                 .setup = alc883_mode2_setup,
10913                 .init_hook = alc_inithook,
10914         },
10915         [ALC888_ASUS_EEE1601] = {
10916                 .mixers = { alc883_asus_eee1601_mixer },
10917                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
10918                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10919                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10920                 .dac_nids = alc883_dac_nids,
10921                 .dig_out_nid = ALC883_DIGOUT_NID,
10922                 .dig_in_nid = ALC883_DIGIN_NID,
10923                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10924                 .channel_mode = alc883_3ST_2ch_modes,
10925                 .need_dac_fix = 1,
10926                 .input_mux = &alc883_asus_eee1601_capture_source,
10927                 .unsol_event = alc_sku_unsol_event,
10928                 .init_hook = alc883_eee1601_inithook,
10929         },
10930         [ALC1200_ASUS_P5Q] = {
10931                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10932                 .init_verbs = { alc883_init_verbs },
10933                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10934                 .dac_nids = alc883_dac_nids,
10935                 .dig_out_nid = ALC1200_DIGOUT_NID,
10936                 .dig_in_nid = ALC883_DIGIN_NID,
10937                 .slave_dig_outs = alc1200_slave_dig_outs,
10938                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10939                 .channel_mode = alc883_sixstack_modes,
10940                 .input_mux = &alc883_capture_source,
10941         },
10942         [ALC889A_MB31] = {
10943                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10944                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10945                         alc880_gpio1_init_verbs },
10946                 .adc_nids = alc883_adc_nids,
10947                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10948                 .capsrc_nids = alc883_capsrc_nids,
10949                 .dac_nids = alc883_dac_nids,
10950                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10951                 .channel_mode = alc889A_mb31_6ch_modes,
10952                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10953                 .input_mux = &alc889A_mb31_capture_source,
10954                 .dig_out_nid = ALC883_DIGOUT_NID,
10955                 .unsol_event = alc889A_mb31_unsol_event,
10956                 .init_hook = alc889A_mb31_automute,
10957         },
10958         [ALC883_SONY_VAIO_TT] = {
10959                 .mixers = { alc883_vaiott_mixer },
10960                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10961                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10962                 .dac_nids = alc883_dac_nids,
10963                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10964                 .channel_mode = alc883_3ST_2ch_modes,
10965                 .input_mux = &alc883_capture_source,
10966                 .unsol_event = alc_sku_unsol_event,
10967                 .setup = alc883_vaiott_setup,
10968                 .init_hook = alc_hp_automute,
10969         },
10970 };
10971
10972
10973 /*
10974  * Pin config fixes
10975  */
10976 enum {
10977         PINFIX_ABIT_AW9D_MAX,
10978         PINFIX_LENOVO_Y530,
10979         PINFIX_PB_M5210,
10980         PINFIX_ACER_ASPIRE_7736,
10981 };
10982
10983 static const struct alc_fixup alc882_fixups[] = {
10984         [PINFIX_ABIT_AW9D_MAX] = {
10985                 .type = ALC_FIXUP_PINS,
10986                 .v.pins = (const struct alc_pincfg[]) {
10987                         { 0x15, 0x01080104 }, /* side */
10988                         { 0x16, 0x01011012 }, /* rear */
10989                         { 0x17, 0x01016011 }, /* clfe */
10990                         { }
10991                 }
10992         },
10993         [PINFIX_LENOVO_Y530] = {
10994                 .type = ALC_FIXUP_PINS,
10995                 .v.pins = (const struct alc_pincfg[]) {
10996                         { 0x15, 0x99130112 }, /* rear int speakers */
10997                         { 0x16, 0x99130111 }, /* subwoofer */
10998                         { }
10999                 }
11000         },
11001         [PINFIX_PB_M5210] = {
11002                 .type = ALC_FIXUP_VERBS,
11003                 .v.verbs = (const struct hda_verb[]) {
11004                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
11005                         {}
11006                 }
11007         },
11008         [PINFIX_ACER_ASPIRE_7736] = {
11009                 .type = ALC_FIXUP_SKU,
11010                 .v.sku = ALC_FIXUP_SKU_IGNORE,
11011         },
11012 };
11013
11014 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
11015         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
11016         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530),
11017         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
11018         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
11019         {}
11020 };
11021
11022 /*
11023  * BIOS auto configuration
11024  */
11025 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
11026                                                 const struct auto_pin_cfg *cfg)
11027 {
11028         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
11029 }
11030
11031 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
11032                                               hda_nid_t nid, int pin_type,
11033                                               hda_nid_t dac)
11034 {
11035         int idx;
11036
11037         /* set as output */
11038         alc_set_pin_output(codec, nid, pin_type);
11039
11040         if (dac == 0x25)
11041                 idx = 4;
11042         else if (dac >= 0x02 && dac <= 0x05)
11043                 idx = dac - 2;
11044         else
11045                 return;
11046         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
11047 }
11048
11049 static void alc882_auto_init_multi_out(struct hda_codec *codec)
11050 {
11051         struct alc_spec *spec = codec->spec;
11052         int i;
11053
11054         for (i = 0; i <= HDA_SIDE; i++) {
11055                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
11056                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
11057                 if (nid)
11058                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
11059                                         spec->multiout.dac_nids[i]);
11060         }
11061 }
11062
11063 static void alc882_auto_init_hp_out(struct hda_codec *codec)
11064 {
11065         struct alc_spec *spec = codec->spec;
11066         hda_nid_t pin, dac;
11067         int i;
11068
11069         if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT) {
11070                 for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
11071                         pin = spec->autocfg.hp_pins[i];
11072                         if (!pin)
11073                                 break;
11074                         dac = spec->multiout.hp_nid;
11075                         if (!dac)
11076                                 dac = spec->multiout.dac_nids[0]; /* to front */
11077                         alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
11078                 }
11079         }
11080
11081         if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT) {
11082                 for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
11083                         pin = spec->autocfg.speaker_pins[i];
11084                         if (!pin)
11085                                 break;
11086                         dac = spec->multiout.extra_out_nid[0];
11087                         if (!dac)
11088                                 dac = spec->multiout.dac_nids[0]; /* to front */
11089                         alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
11090                 }
11091         }
11092 }
11093
11094 static void alc882_auto_init_analog_input(struct hda_codec *codec)
11095 {
11096         struct alc_spec *spec = codec->spec;
11097         struct auto_pin_cfg *cfg = &spec->autocfg;
11098         int i;
11099
11100         for (i = 0; i < cfg->num_inputs; i++) {
11101                 hda_nid_t nid = cfg->inputs[i].pin;
11102                 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
11103                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
11104                         snd_hda_codec_write(codec, nid, 0,
11105                                             AC_VERB_SET_AMP_GAIN_MUTE,
11106                                             AMP_OUT_MUTE);
11107         }
11108 }
11109
11110 static void alc882_auto_init_input_src(struct hda_codec *codec)
11111 {
11112         struct alc_spec *spec = codec->spec;
11113         int c;
11114
11115         for (c = 0; c < spec->num_adc_nids; c++) {
11116                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
11117                 hda_nid_t nid = spec->capsrc_nids[c];
11118                 unsigned int mux_idx;
11119                 const struct hda_input_mux *imux;
11120                 int conns, mute, idx, item;
11121
11122                 /* mute ADC */
11123                 snd_hda_codec_write(codec, spec->adc_nids[c], 0,
11124                                     AC_VERB_SET_AMP_GAIN_MUTE,
11125                                     AMP_IN_MUTE(0));
11126
11127                 conns = snd_hda_get_connections(codec, nid, conn_list,
11128                                                 ARRAY_SIZE(conn_list));
11129                 if (conns < 0)
11130                         continue;
11131                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
11132                 imux = &spec->input_mux[mux_idx];
11133                 if (!imux->num_items && mux_idx > 0)
11134                         imux = &spec->input_mux[0];
11135                 for (idx = 0; idx < conns; idx++) {
11136                         /* if the current connection is the selected one,
11137                          * unmute it as default - otherwise mute it
11138                          */
11139                         mute = AMP_IN_MUTE(idx);
11140                         for (item = 0; item < imux->num_items; item++) {
11141                                 if (imux->items[item].index == idx) {
11142                                         if (spec->cur_mux[c] == item)
11143                                                 mute = AMP_IN_UNMUTE(idx);
11144                                         break;
11145                                 }
11146                         }
11147                         /* check if we have a selector or mixer
11148                          * we could check for the widget type instead, but
11149                          * just check for Amp-In presence (in case of mixer
11150                          * without amp-in there is something wrong, this
11151                          * function shouldn't be used or capsrc nid is wrong)
11152                          */
11153                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
11154                                 snd_hda_codec_write(codec, nid, 0,
11155                                                     AC_VERB_SET_AMP_GAIN_MUTE,
11156                                                     mute);
11157                         else if (mute != AMP_IN_MUTE(idx))
11158                                 snd_hda_codec_write(codec, nid, 0,
11159                                                     AC_VERB_SET_CONNECT_SEL,
11160                                                     idx);
11161                 }
11162         }
11163 }
11164
11165 /* add mic boosts if needed */
11166 static int alc_auto_add_mic_boost(struct hda_codec *codec)
11167 {
11168         struct alc_spec *spec = codec->spec;
11169         struct auto_pin_cfg *cfg = &spec->autocfg;
11170         int i, err;
11171         int type_idx = 0;
11172         hda_nid_t nid;
11173         const char *prev_label = NULL;
11174
11175         for (i = 0; i < cfg->num_inputs; i++) {
11176                 if (cfg->inputs[i].type > AUTO_PIN_MIC)
11177                         break;
11178                 nid = cfg->inputs[i].pin;
11179                 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
11180                         const char *label;
11181                         char boost_label[32];
11182
11183                         label = hda_get_autocfg_input_label(codec, cfg, i);
11184                         if (prev_label && !strcmp(label, prev_label))
11185                                 type_idx++;
11186                         else
11187                                 type_idx = 0;
11188                         prev_label = label;
11189
11190                         snprintf(boost_label, sizeof(boost_label),
11191                                  "%s Boost Volume", label);
11192                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
11193                                           boost_label, type_idx,
11194                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11195                         if (err < 0)
11196                                 return err;
11197                 }
11198         }
11199         return 0;
11200 }
11201
11202 /* almost identical with ALC880 parser... */
11203 static int alc882_parse_auto_config(struct hda_codec *codec)
11204 {
11205         struct alc_spec *spec = codec->spec;
11206         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
11207         int err;
11208
11209         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11210                                            alc882_ignore);
11211         if (err < 0)
11212                 return err;
11213         if (!spec->autocfg.line_outs)
11214                 return 0; /* can't find valid BIOS pin config */
11215
11216         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
11217         if (err < 0)
11218                 return err;
11219         err = alc_auto_add_multi_channel_mode(codec);
11220         if (err < 0)
11221                 return err;
11222         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
11223         if (err < 0)
11224                 return err;
11225         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
11226                                            "Headphone");
11227         if (err < 0)
11228                 return err;
11229         err = alc880_auto_create_extra_out(spec,
11230                                            spec->autocfg.speaker_pins[0],
11231                                            "Speaker");
11232         if (err < 0)
11233                 return err;
11234         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
11235         if (err < 0)
11236                 return err;
11237
11238         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11239
11240         alc_auto_parse_digital(codec);
11241
11242         if (spec->kctls.list)
11243                 add_mixer(spec, spec->kctls.list);
11244
11245         add_verb(spec, alc883_auto_init_verbs);
11246         /* if ADC 0x07 is available, initialize it, too */
11247         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
11248                 add_verb(spec, alc882_adc1_init_verbs);
11249
11250         spec->num_mux_defs = 1;
11251         spec->input_mux = &spec->private_imux[0];
11252
11253         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
11254
11255         err = alc_auto_add_mic_boost(codec);
11256         if (err < 0)
11257                 return err;
11258
11259         return 1; /* config found */
11260 }
11261
11262 /* additional initialization for auto-configuration model */
11263 static void alc882_auto_init(struct hda_codec *codec)
11264 {
11265         struct alc_spec *spec = codec->spec;
11266         alc882_auto_init_multi_out(codec);
11267         alc882_auto_init_hp_out(codec);
11268         alc882_auto_init_analog_input(codec);
11269         alc882_auto_init_input_src(codec);
11270         alc_auto_init_digital(codec);
11271         if (spec->unsol_event)
11272                 alc_inithook(codec);
11273 }
11274
11275 static int patch_alc882(struct hda_codec *codec)
11276 {
11277         struct alc_spec *spec;
11278         int err, board_config;
11279
11280         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11281         if (spec == NULL)
11282                 return -ENOMEM;
11283
11284         codec->spec = spec;
11285
11286         switch (codec->vendor_id) {
11287         case 0x10ec0882:
11288         case 0x10ec0885:
11289                 break;
11290         default:
11291                 /* ALC883 and variants */
11292                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11293                 break;
11294         }
11295
11296         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
11297                                                   alc882_models,
11298                                                   alc882_cfg_tbl);
11299
11300         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
11301                 board_config = snd_hda_check_board_codec_sid_config(codec,
11302                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
11303
11304         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
11305                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
11306                        codec->chip_name);
11307                 board_config = ALC882_AUTO;
11308         }
11309
11310         if (board_config == ALC882_AUTO) {
11311                 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
11312                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
11313         }
11314
11315         alc_auto_parse_customize_define(codec);
11316
11317         if (board_config == ALC882_AUTO) {
11318                 /* automatic parse from the BIOS config */
11319                 err = alc882_parse_auto_config(codec);
11320                 if (err < 0) {
11321                         alc_free(codec);
11322                         return err;
11323                 } else if (!err) {
11324                         printk(KERN_INFO
11325                                "hda_codec: Cannot set up configuration "
11326                                "from BIOS.  Using base mode...\n");
11327                         board_config = ALC882_3ST_DIG;
11328                 }
11329         }
11330
11331         if (has_cdefine_beep(codec)) {
11332                 err = snd_hda_attach_beep_device(codec, 0x1);
11333                 if (err < 0) {
11334                         alc_free(codec);
11335                         return err;
11336                 }
11337         }
11338
11339         if (board_config != ALC882_AUTO)
11340                 setup_preset(codec, &alc882_presets[board_config]);
11341
11342         spec->stream_analog_playback = &alc882_pcm_analog_playback;
11343         spec->stream_analog_capture = &alc882_pcm_analog_capture;
11344         /* FIXME: setup DAC5 */
11345         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
11346         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
11347
11348         spec->stream_digital_playback = &alc882_pcm_digital_playback;
11349         spec->stream_digital_capture = &alc882_pcm_digital_capture;
11350
11351         if (!spec->adc_nids && spec->input_mux) {
11352                 int i, j;
11353                 spec->num_adc_nids = 0;
11354                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
11355                         const struct hda_input_mux *imux = spec->input_mux;
11356                         hda_nid_t cap;
11357                         hda_nid_t items[16];
11358                         hda_nid_t nid = alc882_adc_nids[i];
11359                         unsigned int wcap = get_wcaps(codec, nid);
11360                         /* get type */
11361                         wcap = get_wcaps_type(wcap);
11362                         if (wcap != AC_WID_AUD_IN)
11363                                 continue;
11364                         spec->private_adc_nids[spec->num_adc_nids] = nid;
11365                         err = snd_hda_get_connections(codec, nid, &cap, 1);
11366                         if (err < 0)
11367                                 continue;
11368                         err = snd_hda_get_connections(codec, cap, items,
11369                                                       ARRAY_SIZE(items));
11370                         if (err < 0)
11371                                 continue;
11372                         for (j = 0; j < imux->num_items; j++)
11373                                 if (imux->items[j].index >= err)
11374                                         break;
11375                         if (j < imux->num_items)
11376                                 continue;
11377                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
11378                         spec->num_adc_nids++;
11379                 }
11380                 spec->adc_nids = spec->private_adc_nids;
11381                 spec->capsrc_nids = spec->private_capsrc_nids;
11382         }
11383
11384         set_capture_mixer(codec);
11385
11386         if (has_cdefine_beep(codec))
11387                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11388
11389         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
11390
11391         spec->vmaster_nid = 0x0c;
11392
11393         codec->patch_ops = alc_patch_ops;
11394         if (board_config == ALC882_AUTO)
11395                 spec->init_hook = alc882_auto_init;
11396
11397         alc_init_jacks(codec);
11398 #ifdef CONFIG_SND_HDA_POWER_SAVE
11399         if (!spec->loopback.amplist)
11400                 spec->loopback.amplist = alc882_loopbacks;
11401 #endif
11402
11403         return 0;
11404 }
11405
11406
11407 /*
11408  * ALC262 support
11409  */
11410
11411 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
11412 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
11413
11414 #define alc262_dac_nids         alc260_dac_nids
11415 #define alc262_adc_nids         alc882_adc_nids
11416 #define alc262_adc_nids_alt     alc882_adc_nids_alt
11417 #define alc262_capsrc_nids      alc882_capsrc_nids
11418 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
11419
11420 #define alc262_modes            alc260_modes
11421 #define alc262_capture_source   alc882_capture_source
11422
11423 static const hda_nid_t alc262_dmic_adc_nids[1] = {
11424         /* ADC0 */
11425         0x09
11426 };
11427
11428 static const hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
11429
11430 static const struct snd_kcontrol_new alc262_base_mixer[] = {
11431         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11432         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11433         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11434         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11435         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11436         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11437         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11438         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11439         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11440         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11441         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11442         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11443         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
11444         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11445         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
11446         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11447         { } /* end */
11448 };
11449
11450 /* update HP, line and mono-out pins according to the master switch */
11451 #define alc262_hp_master_update         alc260_hp_master_update
11452
11453 static void alc262_hp_bpc_setup(struct hda_codec *codec)
11454 {
11455         struct alc_spec *spec = codec->spec;
11456
11457         spec->autocfg.hp_pins[0] = 0x1b;
11458         spec->autocfg.speaker_pins[0] = 0x16;
11459         spec->automute = 1;
11460         spec->automute_mode = ALC_AUTOMUTE_PIN;
11461 }
11462
11463 static void alc262_hp_wildwest_setup(struct hda_codec *codec)
11464 {
11465         struct alc_spec *spec = codec->spec;
11466
11467         spec->autocfg.hp_pins[0] = 0x15;
11468         spec->autocfg.speaker_pins[0] = 0x16;
11469         spec->automute = 1;
11470         spec->automute_mode = ALC_AUTOMUTE_PIN;
11471 }
11472
11473 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
11474 #define alc262_hp_master_sw_put         alc260_hp_master_sw_put
11475
11476 #define ALC262_HP_MASTER_SWITCH                                 \
11477         {                                                       \
11478                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11479                 .name = "Master Playback Switch",               \
11480                 .info = snd_ctl_boolean_mono_info,              \
11481                 .get = alc262_hp_master_sw_get,                 \
11482                 .put = alc262_hp_master_sw_put,                 \
11483         }, \
11484         {                                                       \
11485                 .iface = NID_MAPPING,                           \
11486                 .name = "Master Playback Switch",               \
11487                 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
11488         }
11489
11490
11491 static const struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
11492         ALC262_HP_MASTER_SWITCH,
11493         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11494         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11495         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11496         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11497                               HDA_OUTPUT),
11498         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11499                             HDA_OUTPUT),
11500         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11501         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11502         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11503         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11504         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11505         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11506         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11507         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11508         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11509         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11510         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
11511         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
11512         { } /* end */
11513 };
11514
11515 static const struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
11516         ALC262_HP_MASTER_SWITCH,
11517         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11518         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11519         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11520         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11521         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11522                               HDA_OUTPUT),
11523         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11524                             HDA_OUTPUT),
11525         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
11526         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
11527         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x1a, 0, HDA_INPUT),
11528         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11529         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11530         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11531         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11532         { } /* end */
11533 };
11534
11535 static const struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
11536         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11537         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11538         HDA_CODEC_VOLUME("Rear Mic Boost Volume", 0x18, 0, HDA_INPUT),
11539         { } /* end */
11540 };
11541
11542 /* mute/unmute internal speaker according to the hp jack and mute state */
11543 static void alc262_hp_t5735_setup(struct hda_codec *codec)
11544 {
11545         struct alc_spec *spec = codec->spec;
11546
11547         spec->autocfg.hp_pins[0] = 0x15;
11548         spec->autocfg.speaker_pins[0] = 0x14;
11549         spec->automute = 1;
11550         spec->automute_mode = ALC_AUTOMUTE_PIN;
11551 }
11552
11553 static const struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
11554         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11555         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11556         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11557         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11558         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11559         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11560         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11561         { } /* end */
11562 };
11563
11564 static const struct hda_verb alc262_hp_t5735_verbs[] = {
11565         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11566         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11567
11568         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11569         { }
11570 };
11571
11572 static const struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
11573         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11574         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11575         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
11576         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
11577         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11578         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11579         { } /* end */
11580 };
11581
11582 static const struct hda_verb alc262_hp_rp5700_verbs[] = {
11583         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11584         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11585         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11586         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11587         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11588         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11589         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11590         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11591         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11592         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11593         {}
11594 };
11595
11596 static const struct hda_input_mux alc262_hp_rp5700_capture_source = {
11597         .num_items = 1,
11598         .items = {
11599                 { "Line", 0x1 },
11600         },
11601 };
11602
11603 /* bind hp and internal speaker mute (with plug check) as master switch */
11604 #define alc262_hippo_master_update      alc262_hp_master_update
11605 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
11606 #define alc262_hippo_master_sw_put      alc262_hp_master_sw_put
11607
11608 #define ALC262_HIPPO_MASTER_SWITCH                              \
11609         {                                                       \
11610                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11611                 .name = "Master Playback Switch",               \
11612                 .info = snd_ctl_boolean_mono_info,              \
11613                 .get = alc262_hippo_master_sw_get,              \
11614                 .put = alc262_hippo_master_sw_put,              \
11615         },                                                      \
11616         {                                                       \
11617                 .iface = NID_MAPPING,                           \
11618                 .name = "Master Playback Switch",               \
11619                 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
11620                              (SUBDEV_SPEAKER(0) << 16), \
11621         }
11622
11623 static const struct snd_kcontrol_new alc262_hippo_mixer[] = {
11624         ALC262_HIPPO_MASTER_SWITCH,
11625         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11626         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11627         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11628         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11629         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11630         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11631         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11632         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11633         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11634         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11635         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11636         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11637         { } /* end */
11638 };
11639
11640 static const struct snd_kcontrol_new alc262_hippo1_mixer[] = {
11641         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11642         ALC262_HIPPO_MASTER_SWITCH,
11643         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11644         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11645         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11646         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11647         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11648         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11649         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11650         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11651         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11652         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11653         { } /* end */
11654 };
11655
11656 /* mute/unmute internal speaker according to the hp jack and mute state */
11657 static void alc262_hippo_setup(struct hda_codec *codec)
11658 {
11659         struct alc_spec *spec = codec->spec;
11660
11661         spec->autocfg.hp_pins[0] = 0x15;
11662         spec->autocfg.speaker_pins[0] = 0x14;
11663         spec->automute = 1;
11664         spec->automute_mode = ALC_AUTOMUTE_AMP;
11665 }
11666
11667 static void alc262_hippo1_setup(struct hda_codec *codec)
11668 {
11669         struct alc_spec *spec = codec->spec;
11670
11671         spec->autocfg.hp_pins[0] = 0x1b;
11672         spec->autocfg.speaker_pins[0] = 0x14;
11673         spec->automute = 1;
11674         spec->automute_mode = ALC_AUTOMUTE_AMP;
11675 }
11676
11677
11678 static const struct snd_kcontrol_new alc262_sony_mixer[] = {
11679         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11680         ALC262_HIPPO_MASTER_SWITCH,
11681         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11682         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11683         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11684         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11685         { } /* end */
11686 };
11687
11688 static const struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
11689         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11690         ALC262_HIPPO_MASTER_SWITCH,
11691         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11692         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11693         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11694         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11695         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11696         { } /* end */
11697 };
11698
11699 static const struct snd_kcontrol_new alc262_tyan_mixer[] = {
11700         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11701         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11702         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
11703         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
11704         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11705         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11706         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11707         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11708         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11709         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11710         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11711         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11712         { } /* end */
11713 };
11714
11715 static const struct hda_verb alc262_tyan_verbs[] = {
11716         /* Headphone automute */
11717         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11718         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11719         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11720
11721         /* P11 AUX_IN, white 4-pin connector */
11722         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11723         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
11724         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
11725         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
11726
11727         {}
11728 };
11729
11730 /* unsolicited event for HP jack sensing */
11731 static void alc262_tyan_setup(struct hda_codec *codec)
11732 {
11733         struct alc_spec *spec = codec->spec;
11734
11735         spec->autocfg.hp_pins[0] = 0x1b;
11736         spec->autocfg.speaker_pins[0] = 0x15;
11737         spec->automute = 1;
11738         spec->automute_mode = ALC_AUTOMUTE_AMP;
11739 }
11740
11741
11742 #define alc262_capture_mixer            alc882_capture_mixer
11743 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
11744
11745 /*
11746  * generic initialization of ADC, input mixers and output mixers
11747  */
11748 static const struct hda_verb alc262_init_verbs[] = {
11749         /*
11750          * Unmute ADC0-2 and set the default input to mic-in
11751          */
11752         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11753         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11754         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11755         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11756         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11757         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11758
11759         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11760          * mixer widget
11761          * Note: PASD motherboards uses the Line In 2 as the input for
11762          * front panel mic (mic 2)
11763          */
11764         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11765         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11766         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11767         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11768         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11769         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11770
11771         /*
11772          * Set up output mixers (0x0c - 0x0e)
11773          */
11774         /* set vol=0 to output mixers */
11775         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11776         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11777         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11778         /* set up input amps for analog loopback */
11779         /* Amp Indices: DAC = 0, mixer = 1 */
11780         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11781         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11782         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11783         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11784         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11785         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11786
11787         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11788         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11789         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11790         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11791         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11792         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11793
11794         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11795         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11796         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11797         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11798         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11799
11800         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11801         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11802
11803         /* FIXME: use matrix-type input source selection */
11804         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11805         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11806         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11807         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11808         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11809         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11810         /* Input mixer2 */
11811         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11812         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11813         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11814         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11815         /* Input mixer3 */
11816         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11817         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11818         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11819         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11820
11821         { }
11822 };
11823
11824 static const struct hda_verb alc262_eapd_verbs[] = {
11825         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11826         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11827         { }
11828 };
11829
11830 static const struct hda_verb alc262_hippo1_unsol_verbs[] = {
11831         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11832         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11833         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11834
11835         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11836         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11837         {}
11838 };
11839
11840 static const struct hda_verb alc262_sony_unsol_verbs[] = {
11841         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11842         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11843         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
11844
11845         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11846         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11847         {}
11848 };
11849
11850 static const struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
11851         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11852         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11853         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11854         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11855         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11856         { } /* end */
11857 };
11858
11859 static const struct hda_verb alc262_toshiba_s06_verbs[] = {
11860         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11861         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11862         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11863         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11864         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
11865         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11866         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11867         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11868         {}
11869 };
11870
11871 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11872 {
11873         struct alc_spec *spec = codec->spec;
11874
11875         spec->autocfg.hp_pins[0] = 0x15;
11876         spec->autocfg.speaker_pins[0] = 0x14;
11877         spec->ext_mic.pin = 0x18;
11878         spec->ext_mic.mux_idx = 0;
11879         spec->int_mic.pin = 0x12;
11880         spec->int_mic.mux_idx = 9;
11881         spec->auto_mic = 1;
11882         spec->automute = 1;
11883         spec->automute_mode = ALC_AUTOMUTE_PIN;
11884 }
11885
11886 /*
11887  * nec model
11888  *  0x15 = headphone
11889  *  0x16 = internal speaker
11890  *  0x18 = external mic
11891  */
11892
11893 static const struct snd_kcontrol_new alc262_nec_mixer[] = {
11894         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11895         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11896
11897         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11898         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11899         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11900
11901         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11902         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11903         { } /* end */
11904 };
11905
11906 static const struct hda_verb alc262_nec_verbs[] = {
11907         /* Unmute Speaker */
11908         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11909
11910         /* Headphone */
11911         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11912         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11913
11914         /* External mic to headphone */
11915         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11916         /* External mic to speaker */
11917         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11918         {}
11919 };
11920
11921 /*
11922  * fujitsu model
11923  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11924  *  0x1b = port replicator headphone out
11925  */
11926
11927 #define ALC_HP_EVENT    ALC880_HP_EVENT
11928
11929 static const struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11930         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11931         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11932         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11933         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11934         {}
11935 };
11936
11937 static const struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11938         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11939         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11940         {}
11941 };
11942
11943 static const struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11944         /* Front Mic pin: input vref at 50% */
11945         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11946         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11947         {}
11948 };
11949
11950 static const struct hda_input_mux alc262_fujitsu_capture_source = {
11951         .num_items = 3,
11952         .items = {
11953                 { "Mic", 0x0 },
11954                 { "Internal Mic", 0x1 },
11955                 { "CD", 0x4 },
11956         },
11957 };
11958
11959 static const struct hda_input_mux alc262_HP_capture_source = {
11960         .num_items = 5,
11961         .items = {
11962                 { "Mic", 0x0 },
11963                 { "Front Mic", 0x1 },
11964                 { "Line", 0x2 },
11965                 { "CD", 0x4 },
11966                 { "AUX IN", 0x6 },
11967         },
11968 };
11969
11970 static const struct hda_input_mux alc262_HP_D7000_capture_source = {
11971         .num_items = 4,
11972         .items = {
11973                 { "Mic", 0x0 },
11974                 { "Front Mic", 0x2 },
11975                 { "Line", 0x1 },
11976                 { "CD", 0x4 },
11977         },
11978 };
11979
11980 static void alc262_fujitsu_setup(struct hda_codec *codec)
11981 {
11982         struct alc_spec *spec = codec->spec;
11983
11984         spec->autocfg.hp_pins[0] = 0x14;
11985         spec->autocfg.hp_pins[1] = 0x1b;
11986         spec->autocfg.speaker_pins[0] = 0x15;
11987         spec->automute = 1;
11988         spec->automute_mode = ALC_AUTOMUTE_AMP;
11989 }
11990
11991 /* bind volumes of both NID 0x0c and 0x0d */
11992 static const struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11993         .ops = &snd_hda_bind_vol,
11994         .values = {
11995                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11996                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11997                 0
11998         },
11999 };
12000
12001 static const struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
12002         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
12003         {
12004                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12005                 .name = "Master Playback Switch",
12006                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x14,
12007                 .info = snd_ctl_boolean_mono_info,
12008                 .get = alc262_hp_master_sw_get,
12009                 .put = alc262_hp_master_sw_put,
12010         },
12011         {
12012                 .iface = NID_MAPPING,
12013                 .name = "Master Playback Switch",
12014                 .private_value = 0x1b,
12015         },
12016         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12017         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12018         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
12019         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12020         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12021         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
12022         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12023         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12024         { } /* end */
12025 };
12026
12027 static void alc262_lenovo_3000_setup(struct hda_codec *codec)
12028 {
12029         struct alc_spec *spec = codec->spec;
12030
12031         spec->autocfg.hp_pins[0] = 0x1b;
12032         spec->autocfg.speaker_pins[0] = 0x14;
12033         spec->autocfg.speaker_pins[1] = 0x16;
12034         spec->automute = 1;
12035         spec->automute_mode = ALC_AUTOMUTE_AMP;
12036 }
12037
12038 static const struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
12039         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
12040         {
12041                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12042                 .name = "Master Playback Switch",
12043                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x1b,
12044                 .info = snd_ctl_boolean_mono_info,
12045                 .get = alc262_hp_master_sw_get,
12046                 .put = alc262_hp_master_sw_put,
12047         },
12048         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12049         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12050         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
12051         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12052         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12053         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
12054         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12055         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12056         { } /* end */
12057 };
12058
12059 static const struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
12060         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
12061         ALC262_HIPPO_MASTER_SWITCH,
12062         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12063         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12064         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
12065         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12066         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12067         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
12068         { } /* end */
12069 };
12070
12071 /* additional init verbs for Benq laptops */
12072 static const struct hda_verb alc262_EAPD_verbs[] = {
12073         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
12074         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
12075         {}
12076 };
12077
12078 static const struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
12079         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12080         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12081
12082         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
12083         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
12084         {}
12085 };
12086
12087 /* Samsung Q1 Ultra Vista model setup */
12088 static const struct snd_kcontrol_new alc262_ultra_mixer[] = {
12089         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
12090         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
12091         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12092         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12093         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
12094         HDA_CODEC_VOLUME("Headphone Mic Boost Volume", 0x15, 0, HDA_INPUT),
12095         { } /* end */
12096 };
12097
12098 static const struct hda_verb alc262_ultra_verbs[] = {
12099         /* output mixer */
12100         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12101         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12102         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12103         /* speaker */
12104         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12105         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12106         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12107         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12108         /* HP */
12109         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12110         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12111         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12112         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12113         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12114         /* internal mic */
12115         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12116         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12117         /* ADC, choose mic */
12118         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12119         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12120         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12121         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12122         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12123         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12124         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12125         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12126         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12127         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
12128         {}
12129 };
12130
12131 /* mute/unmute internal speaker according to the hp jack and mute state */
12132 static void alc262_ultra_automute(struct hda_codec *codec)
12133 {
12134         struct alc_spec *spec = codec->spec;
12135         unsigned int mute;
12136
12137         mute = 0;
12138         /* auto-mute only when HP is used as HP */
12139         if (!spec->cur_mux[0]) {
12140                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
12141                 if (spec->jack_present)
12142                         mute = HDA_AMP_MUTE;
12143         }
12144         /* mute/unmute internal speaker */
12145         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
12146                                  HDA_AMP_MUTE, mute);
12147         /* mute/unmute HP */
12148         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12149                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
12150 }
12151
12152 /* unsolicited event for HP jack sensing */
12153 static void alc262_ultra_unsol_event(struct hda_codec *codec,
12154                                        unsigned int res)
12155 {
12156         if ((res >> 26) != ALC880_HP_EVENT)
12157                 return;
12158         alc262_ultra_automute(codec);
12159 }
12160
12161 static const struct hda_input_mux alc262_ultra_capture_source = {
12162         .num_items = 2,
12163         .items = {
12164                 { "Mic", 0x1 },
12165                 { "Headphone", 0x7 },
12166         },
12167 };
12168
12169 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
12170                                      struct snd_ctl_elem_value *ucontrol)
12171 {
12172         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12173         struct alc_spec *spec = codec->spec;
12174         int ret;
12175
12176         ret = alc_mux_enum_put(kcontrol, ucontrol);
12177         if (!ret)
12178                 return 0;
12179         /* reprogram the HP pin as mic or HP according to the input source */
12180         snd_hda_codec_write_cache(codec, 0x15, 0,
12181                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
12182                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
12183         alc262_ultra_automute(codec); /* mute/unmute HP */
12184         return ret;
12185 }
12186
12187 static const struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
12188         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
12189         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
12190         {
12191                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12192                 .name = "Capture Source",
12193                 .info = alc_mux_enum_info,
12194                 .get = alc_mux_enum_get,
12195                 .put = alc262_ultra_mux_enum_put,
12196         },
12197         {
12198                 .iface = NID_MAPPING,
12199                 .name = "Capture Source",
12200                 .private_value = 0x15,
12201         },
12202         { } /* end */
12203 };
12204
12205 /* We use two mixers depending on the output pin; 0x16 is a mono output
12206  * and thus it's bound with a different mixer.
12207  * This function returns which mixer amp should be used.
12208  */
12209 static int alc262_check_volbit(hda_nid_t nid)
12210 {
12211         if (!nid)
12212                 return 0;
12213         else if (nid == 0x16)
12214                 return 2;
12215         else
12216                 return 1;
12217 }
12218
12219 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
12220                                   const char *pfx, int *vbits, int idx)
12221 {
12222         unsigned long val;
12223         int vbit;
12224
12225         vbit = alc262_check_volbit(nid);
12226         if (!vbit)
12227                 return 0;
12228         if (*vbits & vbit) /* a volume control for this mixer already there */
12229                 return 0;
12230         *vbits |= vbit;
12231         if (vbit == 2)
12232                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
12233         else
12234                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
12235         return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val);
12236 }
12237
12238 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
12239                                  const char *pfx, int idx)
12240 {
12241         unsigned long val;
12242
12243         if (!nid)
12244                 return 0;
12245         if (nid == 0x16)
12246                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
12247         else
12248                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
12249         return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val);
12250 }
12251
12252 /* add playback controls from the parsed DAC table */
12253 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
12254                                              const struct auto_pin_cfg *cfg)
12255 {
12256         const char *pfx;
12257         int vbits;
12258         int i, err;
12259
12260         spec->multiout.num_dacs = 1;    /* only use one dac */
12261         spec->multiout.dac_nids = spec->private_dac_nids;
12262         spec->private_dac_nids[0] = 2;
12263
12264         pfx = alc_get_line_out_pfx(spec, true);
12265         if (!pfx)
12266                 pfx = "Front";
12267         for (i = 0; i < 2; i++) {
12268                 err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx, i);
12269                 if (err < 0)
12270                         return err;
12271                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12272                         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i],
12273                                                     "Speaker", i);
12274                         if (err < 0)
12275                                 return err;
12276                 }
12277                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12278                         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i],
12279                                                     "Headphone", i);
12280                         if (err < 0)
12281                                 return err;
12282                 }
12283         }
12284
12285         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
12286                 alc262_check_volbit(cfg->speaker_pins[0]) |
12287                 alc262_check_volbit(cfg->hp_pins[0]);
12288         if (vbits == 1 || vbits == 2)
12289                 pfx = "Master"; /* only one mixer is used */
12290         vbits = 0;
12291         for (i = 0; i < 2; i++) {
12292                 err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx,
12293                                              &vbits, i);
12294                 if (err < 0)
12295                         return err;
12296                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12297                         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i],
12298                                                      "Speaker", &vbits, i);
12299                         if (err < 0)
12300                                 return err;
12301                 }
12302                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12303                         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i],
12304                                                      "Headphone", &vbits, i);
12305                         if (err < 0)
12306                                 return err;
12307                 }
12308         }
12309         return 0;
12310 }
12311
12312 #define alc262_auto_create_input_ctls \
12313         alc882_auto_create_input_ctls
12314
12315 /*
12316  * generic initialization of ADC, input mixers and output mixers
12317  */
12318 static const struct hda_verb alc262_volume_init_verbs[] = {
12319         /*
12320          * Unmute ADC0-2 and set the default input to mic-in
12321          */
12322         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12323         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12324         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12325         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12326         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12327         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12328
12329         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12330          * mixer widget
12331          * Note: PASD motherboards uses the Line In 2 as the input for
12332          * front panel mic (mic 2)
12333          */
12334         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12335         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12336         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12337         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12338         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12339         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12340
12341         /*
12342          * Set up output mixers (0x0c - 0x0f)
12343          */
12344         /* set vol=0 to output mixers */
12345         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12346         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12347         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12348
12349         /* set up input amps for analog loopback */
12350         /* Amp Indices: DAC = 0, mixer = 1 */
12351         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12352         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12353         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12354         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12355         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12356         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12357
12358         /* FIXME: use matrix-type input source selection */
12359         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12360         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12361         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12362         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12363         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12364         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12365         /* Input mixer2 */
12366         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12367         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12368         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12369         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12370         /* Input mixer3 */
12371         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12372         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12373         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12374         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12375
12376         { }
12377 };
12378
12379 static const struct hda_verb alc262_HP_BPC_init_verbs[] = {
12380         /*
12381          * Unmute ADC0-2 and set the default input to mic-in
12382          */
12383         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12384         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12385         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12386         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12387         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12388         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12389
12390         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12391          * mixer widget
12392          * Note: PASD motherboards uses the Line In 2 as the input for
12393          * front panel mic (mic 2)
12394          */
12395         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12396         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12397         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12398         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12399         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12400         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12401         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12402         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12403
12404         /*
12405          * Set up output mixers (0x0c - 0x0e)
12406          */
12407         /* set vol=0 to output mixers */
12408         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12409         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12410         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12411
12412         /* set up input amps for analog loopback */
12413         /* Amp Indices: DAC = 0, mixer = 1 */
12414         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12415         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12416         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12417         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12418         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12419         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12420
12421         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12422         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12423         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12424
12425         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12426         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12427
12428         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12429         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12430
12431         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12432         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12433         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12434         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12435         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12436
12437         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12438         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12439         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12440         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12441         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12442         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12443
12444
12445         /* FIXME: use matrix-type input source selection */
12446         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
12447         /* Input mixer1: only unmute Mic */
12448         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12449         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12450         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12451         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12452         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12453         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12454         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12455         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12456         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12457         /* Input mixer2 */
12458         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12459         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12460         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12461         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12462         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12463         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12464         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12465         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12466         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12467         /* Input mixer3 */
12468         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12469         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12470         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12471         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12472         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12473         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12474         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12475         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12476         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12477
12478         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12479
12480         { }
12481 };
12482
12483 static const struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
12484         /*
12485          * Unmute ADC0-2 and set the default input to mic-in
12486          */
12487         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12488         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12489         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12490         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12491         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12492         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12493
12494         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12495          * mixer widget
12496          * Note: PASD motherboards uses the Line In 2 as the input for front
12497          * panel mic (mic 2)
12498          */
12499         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12500         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12501         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12502         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12503         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12504         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12505         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12506         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12507         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12508         /*
12509          * Set up output mixers (0x0c - 0x0e)
12510          */
12511         /* set vol=0 to output mixers */
12512         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12513         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12514         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12515
12516         /* set up input amps for analog loopback */
12517         /* Amp Indices: DAC = 0, mixer = 1 */
12518         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12519         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12520         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12521         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12522         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12523         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12524
12525
12526         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
12527         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
12528         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
12529         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
12530         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12531         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
12532         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
12533
12534         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12535         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12536
12537         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12538         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12539
12540         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
12541         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12542         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12543         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
12544         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12545         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12546
12547         /* FIXME: use matrix-type input source selection */
12548         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12549         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12550         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
12551         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
12552         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
12553         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
12554         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
12555         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
12556         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
12557         /* Input mixer2 */
12558         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12559         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12560         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12561         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12562         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12563         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12564         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12565         /* Input mixer3 */
12566         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12567         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12568         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12569         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12570         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12571         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12572         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12573
12574         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12575
12576         { }
12577 };
12578
12579 static const struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
12580
12581         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
12582         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12583         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
12584
12585         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
12586         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12587         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12588         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12589
12590         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
12591         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12592         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12593         {}
12594 };
12595
12596 /*
12597  * Pin config fixes
12598  */
12599 enum {
12600         PINFIX_FSC_H270,
12601 };
12602
12603 static const struct alc_fixup alc262_fixups[] = {
12604         [PINFIX_FSC_H270] = {
12605                 .type = ALC_FIXUP_PINS,
12606                 .v.pins = (const struct alc_pincfg[]) {
12607                         { 0x14, 0x99130110 }, /* speaker */
12608                         { 0x15, 0x0221142f }, /* front HP */
12609                         { 0x1b, 0x0121141f }, /* rear HP */
12610                         { }
12611                 }
12612         },
12613 };
12614
12615 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
12616         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
12617         {}
12618 };
12619
12620
12621 #ifdef CONFIG_SND_HDA_POWER_SAVE
12622 #define alc262_loopbacks        alc880_loopbacks
12623 #endif
12624
12625 /* pcm configuration: identical with ALC880 */
12626 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
12627 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
12628 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
12629 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
12630
12631 /*
12632  * BIOS auto configuration
12633  */
12634 static int alc262_parse_auto_config(struct hda_codec *codec)
12635 {
12636         struct alc_spec *spec = codec->spec;
12637         int err;
12638         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
12639
12640         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12641                                            alc262_ignore);
12642         if (err < 0)
12643                 return err;
12644         if (!spec->autocfg.line_outs) {
12645                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12646                         spec->multiout.max_channels = 2;
12647                         spec->no_analog = 1;
12648                         goto dig_only;
12649                 }
12650                 return 0; /* can't find valid BIOS pin config */
12651         }
12652         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
12653         if (err < 0)
12654                 return err;
12655         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
12656         if (err < 0)
12657                 return err;
12658
12659         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12660
12661  dig_only:
12662         alc_auto_parse_digital(codec);
12663
12664         if (spec->kctls.list)
12665                 add_mixer(spec, spec->kctls.list);
12666
12667         add_verb(spec, alc262_volume_init_verbs);
12668         spec->num_mux_defs = 1;
12669         spec->input_mux = &spec->private_imux[0];
12670
12671         err = alc_auto_add_mic_boost(codec);
12672         if (err < 0)
12673                 return err;
12674
12675         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
12676
12677         return 1;
12678 }
12679
12680 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
12681 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
12682 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
12683 #define alc262_auto_init_input_src      alc882_auto_init_input_src
12684
12685
12686 /* init callback for auto-configuration model -- overriding the default init */
12687 static void alc262_auto_init(struct hda_codec *codec)
12688 {
12689         struct alc_spec *spec = codec->spec;
12690         alc262_auto_init_multi_out(codec);
12691         alc262_auto_init_hp_out(codec);
12692         alc262_auto_init_analog_input(codec);
12693         alc262_auto_init_input_src(codec);
12694         alc_auto_init_digital(codec);
12695         if (spec->unsol_event)
12696                 alc_inithook(codec);
12697 }
12698
12699 /*
12700  * configuration and preset
12701  */
12702 static const char * const alc262_models[ALC262_MODEL_LAST] = {
12703         [ALC262_BASIC]          = "basic",
12704         [ALC262_HIPPO]          = "hippo",
12705         [ALC262_HIPPO_1]        = "hippo_1",
12706         [ALC262_FUJITSU]        = "fujitsu",
12707         [ALC262_HP_BPC]         = "hp-bpc",
12708         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
12709         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
12710         [ALC262_HP_RP5700]      = "hp-rp5700",
12711         [ALC262_BENQ_ED8]       = "benq",
12712         [ALC262_BENQ_T31]       = "benq-t31",
12713         [ALC262_SONY_ASSAMD]    = "sony-assamd",
12714         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
12715         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
12716         [ALC262_ULTRA]          = "ultra",
12717         [ALC262_LENOVO_3000]    = "lenovo-3000",
12718         [ALC262_NEC]            = "nec",
12719         [ALC262_TYAN]           = "tyan",
12720         [ALC262_AUTO]           = "auto",
12721 };
12722
12723 static const struct snd_pci_quirk alc262_cfg_tbl[] = {
12724         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
12725         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
12726         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
12727                            ALC262_HP_BPC),
12728         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
12729                            ALC262_HP_BPC),
12730         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1500, "HP z series",
12731                            ALC262_HP_BPC),
12732         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
12733                            ALC262_HP_BPC),
12734         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
12735         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
12736         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
12737         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
12738         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
12739         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
12740         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
12741         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
12742         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
12743         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
12744         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
12745         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
12746                       ALC262_HP_TC_T5735),
12747         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
12748         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12749         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
12750         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12751         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
12752         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
12753         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
12754         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
12755 #if 0 /* disable the quirk since model=auto works better in recent versions */
12756         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
12757                            ALC262_SONY_ASSAMD),
12758 #endif
12759         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
12760                       ALC262_TOSHIBA_RX1),
12761         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
12762         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
12763         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
12764         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
12765         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
12766                            ALC262_ULTRA),
12767         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
12768         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
12769         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
12770         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
12771         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
12772         {}
12773 };
12774
12775 static const struct alc_config_preset alc262_presets[] = {
12776         [ALC262_BASIC] = {
12777                 .mixers = { alc262_base_mixer },
12778                 .init_verbs = { alc262_init_verbs },
12779                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12780                 .dac_nids = alc262_dac_nids,
12781                 .hp_nid = 0x03,
12782                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12783                 .channel_mode = alc262_modes,
12784                 .input_mux = &alc262_capture_source,
12785         },
12786         [ALC262_HIPPO] = {
12787                 .mixers = { alc262_hippo_mixer },
12788                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
12789                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12790                 .dac_nids = alc262_dac_nids,
12791                 .hp_nid = 0x03,
12792                 .dig_out_nid = ALC262_DIGOUT_NID,
12793                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12794                 .channel_mode = alc262_modes,
12795                 .input_mux = &alc262_capture_source,
12796                 .unsol_event = alc_sku_unsol_event,
12797                 .setup = alc262_hippo_setup,
12798                 .init_hook = alc_inithook,
12799         },
12800         [ALC262_HIPPO_1] = {
12801                 .mixers = { alc262_hippo1_mixer },
12802                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
12803                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12804                 .dac_nids = alc262_dac_nids,
12805                 .hp_nid = 0x02,
12806                 .dig_out_nid = ALC262_DIGOUT_NID,
12807                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12808                 .channel_mode = alc262_modes,
12809                 .input_mux = &alc262_capture_source,
12810                 .unsol_event = alc_sku_unsol_event,
12811                 .setup = alc262_hippo1_setup,
12812                 .init_hook = alc_inithook,
12813         },
12814         [ALC262_FUJITSU] = {
12815                 .mixers = { alc262_fujitsu_mixer },
12816                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12817                                 alc262_fujitsu_unsol_verbs },
12818                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12819                 .dac_nids = alc262_dac_nids,
12820                 .hp_nid = 0x03,
12821                 .dig_out_nid = ALC262_DIGOUT_NID,
12822                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12823                 .channel_mode = alc262_modes,
12824                 .input_mux = &alc262_fujitsu_capture_source,
12825                 .unsol_event = alc_sku_unsol_event,
12826                 .setup = alc262_fujitsu_setup,
12827                 .init_hook = alc_inithook,
12828         },
12829         [ALC262_HP_BPC] = {
12830                 .mixers = { alc262_HP_BPC_mixer },
12831                 .init_verbs = { alc262_HP_BPC_init_verbs },
12832                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12833                 .dac_nids = alc262_dac_nids,
12834                 .hp_nid = 0x03,
12835                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12836                 .channel_mode = alc262_modes,
12837                 .input_mux = &alc262_HP_capture_source,
12838                 .unsol_event = alc_sku_unsol_event,
12839                 .setup = alc262_hp_bpc_setup,
12840                 .init_hook = alc_inithook,
12841         },
12842         [ALC262_HP_BPC_D7000_WF] = {
12843                 .mixers = { alc262_HP_BPC_WildWest_mixer },
12844                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12845                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12846                 .dac_nids = alc262_dac_nids,
12847                 .hp_nid = 0x03,
12848                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12849                 .channel_mode = alc262_modes,
12850                 .input_mux = &alc262_HP_D7000_capture_source,
12851                 .unsol_event = alc_sku_unsol_event,
12852                 .setup = alc262_hp_wildwest_setup,
12853                 .init_hook = alc_inithook,
12854         },
12855         [ALC262_HP_BPC_D7000_WL] = {
12856                 .mixers = { alc262_HP_BPC_WildWest_mixer,
12857                             alc262_HP_BPC_WildWest_option_mixer },
12858                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12859                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12860                 .dac_nids = alc262_dac_nids,
12861                 .hp_nid = 0x03,
12862                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12863                 .channel_mode = alc262_modes,
12864                 .input_mux = &alc262_HP_D7000_capture_source,
12865                 .unsol_event = alc_sku_unsol_event,
12866                 .setup = alc262_hp_wildwest_setup,
12867                 .init_hook = alc_inithook,
12868         },
12869         [ALC262_HP_TC_T5735] = {
12870                 .mixers = { alc262_hp_t5735_mixer },
12871                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12872                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12873                 .dac_nids = alc262_dac_nids,
12874                 .hp_nid = 0x03,
12875                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12876                 .channel_mode = alc262_modes,
12877                 .input_mux = &alc262_capture_source,
12878                 .unsol_event = alc_sku_unsol_event,
12879                 .setup = alc262_hp_t5735_setup,
12880                 .init_hook = alc_inithook,
12881         },
12882         [ALC262_HP_RP5700] = {
12883                 .mixers = { alc262_hp_rp5700_mixer },
12884                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12885                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12886                 .dac_nids = alc262_dac_nids,
12887                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12888                 .channel_mode = alc262_modes,
12889                 .input_mux = &alc262_hp_rp5700_capture_source,
12890         },
12891         [ALC262_BENQ_ED8] = {
12892                 .mixers = { alc262_base_mixer },
12893                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12894                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12895                 .dac_nids = alc262_dac_nids,
12896                 .hp_nid = 0x03,
12897                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12898                 .channel_mode = alc262_modes,
12899                 .input_mux = &alc262_capture_source,
12900         },
12901         [ALC262_SONY_ASSAMD] = {
12902                 .mixers = { alc262_sony_mixer },
12903                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12904                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12905                 .dac_nids = alc262_dac_nids,
12906                 .hp_nid = 0x02,
12907                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12908                 .channel_mode = alc262_modes,
12909                 .input_mux = &alc262_capture_source,
12910                 .unsol_event = alc_sku_unsol_event,
12911                 .setup = alc262_hippo_setup,
12912                 .init_hook = alc_inithook,
12913         },
12914         [ALC262_BENQ_T31] = {
12915                 .mixers = { alc262_benq_t31_mixer },
12916                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12917                                 alc_hp15_unsol_verbs },
12918                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12919                 .dac_nids = alc262_dac_nids,
12920                 .hp_nid = 0x03,
12921                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12922                 .channel_mode = alc262_modes,
12923                 .input_mux = &alc262_capture_source,
12924                 .unsol_event = alc_sku_unsol_event,
12925                 .setup = alc262_hippo_setup,
12926                 .init_hook = alc_inithook,
12927         },
12928         [ALC262_ULTRA] = {
12929                 .mixers = { alc262_ultra_mixer },
12930                 .cap_mixer = alc262_ultra_capture_mixer,
12931                 .init_verbs = { alc262_ultra_verbs },
12932                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12933                 .dac_nids = alc262_dac_nids,
12934                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12935                 .channel_mode = alc262_modes,
12936                 .input_mux = &alc262_ultra_capture_source,
12937                 .adc_nids = alc262_adc_nids, /* ADC0 */
12938                 .capsrc_nids = alc262_capsrc_nids,
12939                 .num_adc_nids = 1, /* single ADC */
12940                 .unsol_event = alc262_ultra_unsol_event,
12941                 .init_hook = alc262_ultra_automute,
12942         },
12943         [ALC262_LENOVO_3000] = {
12944                 .mixers = { alc262_lenovo_3000_mixer },
12945                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12946                                 alc262_lenovo_3000_unsol_verbs,
12947                                 alc262_lenovo_3000_init_verbs },
12948                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12949                 .dac_nids = alc262_dac_nids,
12950                 .hp_nid = 0x03,
12951                 .dig_out_nid = ALC262_DIGOUT_NID,
12952                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12953                 .channel_mode = alc262_modes,
12954                 .input_mux = &alc262_fujitsu_capture_source,
12955                 .unsol_event = alc_sku_unsol_event,
12956                 .setup = alc262_lenovo_3000_setup,
12957                 .init_hook = alc_inithook,
12958         },
12959         [ALC262_NEC] = {
12960                 .mixers = { alc262_nec_mixer },
12961                 .init_verbs = { alc262_nec_verbs },
12962                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12963                 .dac_nids = alc262_dac_nids,
12964                 .hp_nid = 0x03,
12965                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12966                 .channel_mode = alc262_modes,
12967                 .input_mux = &alc262_capture_source,
12968         },
12969         [ALC262_TOSHIBA_S06] = {
12970                 .mixers = { alc262_toshiba_s06_mixer },
12971                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12972                                                         alc262_eapd_verbs },
12973                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12974                 .capsrc_nids = alc262_dmic_capsrc_nids,
12975                 .dac_nids = alc262_dac_nids,
12976                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12977                 .num_adc_nids = 1, /* single ADC */
12978                 .dig_out_nid = ALC262_DIGOUT_NID,
12979                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12980                 .channel_mode = alc262_modes,
12981                 .unsol_event = alc_sku_unsol_event,
12982                 .setup = alc262_toshiba_s06_setup,
12983                 .init_hook = alc_inithook,
12984         },
12985         [ALC262_TOSHIBA_RX1] = {
12986                 .mixers = { alc262_toshiba_rx1_mixer },
12987                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12988                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12989                 .dac_nids = alc262_dac_nids,
12990                 .hp_nid = 0x03,
12991                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12992                 .channel_mode = alc262_modes,
12993                 .input_mux = &alc262_capture_source,
12994                 .unsol_event = alc_sku_unsol_event,
12995                 .setup = alc262_hippo_setup,
12996                 .init_hook = alc_inithook,
12997         },
12998         [ALC262_TYAN] = {
12999                 .mixers = { alc262_tyan_mixer },
13000                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
13001                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
13002                 .dac_nids = alc262_dac_nids,
13003                 .hp_nid = 0x02,
13004                 .dig_out_nid = ALC262_DIGOUT_NID,
13005                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
13006                 .channel_mode = alc262_modes,
13007                 .input_mux = &alc262_capture_source,
13008                 .unsol_event = alc_sku_unsol_event,
13009                 .setup = alc262_tyan_setup,
13010                 .init_hook = alc_hp_automute,
13011         },
13012 };
13013
13014 static int patch_alc262(struct hda_codec *codec)
13015 {
13016         struct alc_spec *spec;
13017         int board_config;
13018         int err;
13019
13020         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13021         if (spec == NULL)
13022                 return -ENOMEM;
13023
13024         codec->spec = spec;
13025 #if 0
13026         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
13027          * under-run
13028          */
13029         {
13030         int tmp;
13031         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
13032         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
13033         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
13034         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
13035         }
13036 #endif
13037         alc_auto_parse_customize_define(codec);
13038
13039         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
13040
13041         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
13042                                                   alc262_models,
13043                                                   alc262_cfg_tbl);
13044
13045         if (board_config < 0) {
13046                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13047                        codec->chip_name);
13048                 board_config = ALC262_AUTO;
13049         }
13050
13051         if (board_config == ALC262_AUTO) {
13052                 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
13053                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
13054         }
13055
13056         if (board_config == ALC262_AUTO) {
13057                 /* automatic parse from the BIOS config */
13058                 err = alc262_parse_auto_config(codec);
13059                 if (err < 0) {
13060                         alc_free(codec);
13061                         return err;
13062                 } else if (!err) {
13063                         printk(KERN_INFO
13064                                "hda_codec: Cannot set up configuration "
13065                                "from BIOS.  Using base mode...\n");
13066                         board_config = ALC262_BASIC;
13067                 }
13068         }
13069
13070         if (!spec->no_analog && has_cdefine_beep(codec)) {
13071                 err = snd_hda_attach_beep_device(codec, 0x1);
13072                 if (err < 0) {
13073                         alc_free(codec);
13074                         return err;
13075                 }
13076         }
13077
13078         if (board_config != ALC262_AUTO)
13079                 setup_preset(codec, &alc262_presets[board_config]);
13080
13081         spec->stream_analog_playback = &alc262_pcm_analog_playback;
13082         spec->stream_analog_capture = &alc262_pcm_analog_capture;
13083
13084         spec->stream_digital_playback = &alc262_pcm_digital_playback;
13085         spec->stream_digital_capture = &alc262_pcm_digital_capture;
13086
13087         if (!spec->adc_nids && spec->input_mux) {
13088                 int i;
13089                 /* check whether the digital-mic has to be supported */
13090                 for (i = 0; i < spec->input_mux->num_items; i++) {
13091                         if (spec->input_mux->items[i].index >= 9)
13092                                 break;
13093                 }
13094                 if (i < spec->input_mux->num_items) {
13095                         /* use only ADC0 */
13096                         spec->adc_nids = alc262_dmic_adc_nids;
13097                         spec->num_adc_nids = 1;
13098                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
13099                 } else {
13100                         /* all analog inputs */
13101                         /* check whether NID 0x07 is valid */
13102                         unsigned int wcap = get_wcaps(codec, 0x07);
13103
13104                         /* get type */
13105                         wcap = get_wcaps_type(wcap);
13106                         if (wcap != AC_WID_AUD_IN) {
13107                                 spec->adc_nids = alc262_adc_nids_alt;
13108                                 spec->num_adc_nids =
13109                                         ARRAY_SIZE(alc262_adc_nids_alt);
13110                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
13111                         } else {
13112                                 spec->adc_nids = alc262_adc_nids;
13113                                 spec->num_adc_nids =
13114                                         ARRAY_SIZE(alc262_adc_nids);
13115                                 spec->capsrc_nids = alc262_capsrc_nids;
13116                         }
13117                 }
13118         }
13119         if (!spec->cap_mixer && !spec->no_analog)
13120                 set_capture_mixer(codec);
13121         if (!spec->no_analog && has_cdefine_beep(codec))
13122                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
13123
13124         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
13125
13126         spec->vmaster_nid = 0x0c;
13127
13128         codec->patch_ops = alc_patch_ops;
13129         if (board_config == ALC262_AUTO)
13130                 spec->init_hook = alc262_auto_init;
13131         spec->shutup = alc_eapd_shutup;
13132
13133         alc_init_jacks(codec);
13134 #ifdef CONFIG_SND_HDA_POWER_SAVE
13135         if (!spec->loopback.amplist)
13136                 spec->loopback.amplist = alc262_loopbacks;
13137 #endif
13138
13139         return 0;
13140 }
13141
13142 /*
13143  *  ALC268 channel source setting (2 channel)
13144  */
13145 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
13146 #define alc268_modes            alc260_modes
13147
13148 static const hda_nid_t alc268_dac_nids[2] = {
13149         /* front, hp */
13150         0x02, 0x03
13151 };
13152
13153 static const hda_nid_t alc268_adc_nids[2] = {
13154         /* ADC0-1 */
13155         0x08, 0x07
13156 };
13157
13158 static const hda_nid_t alc268_adc_nids_alt[1] = {
13159         /* ADC0 */
13160         0x08
13161 };
13162
13163 static const hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
13164
13165 static const struct snd_kcontrol_new alc268_base_mixer[] = {
13166         /* output mixer control */
13167         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13168         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13169         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13170         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13171         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13172         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
13173         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13174         { }
13175 };
13176
13177 static const struct snd_kcontrol_new alc268_toshiba_mixer[] = {
13178         /* output mixer control */
13179         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13180         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13181         ALC262_HIPPO_MASTER_SWITCH,
13182         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13183         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
13184         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13185         { }
13186 };
13187
13188 /* bind Beep switches of both NID 0x0f and 0x10 */
13189 static const struct hda_bind_ctls alc268_bind_beep_sw = {
13190         .ops = &snd_hda_bind_sw,
13191         .values = {
13192                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
13193                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
13194                 0
13195         },
13196 };
13197
13198 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
13199         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
13200         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
13201         { }
13202 };
13203
13204 static const struct hda_verb alc268_eapd_verbs[] = {
13205         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13206         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13207         { }
13208 };
13209
13210 /* Toshiba specific */
13211 static const struct hda_verb alc268_toshiba_verbs[] = {
13212         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13213         { } /* end */
13214 };
13215
13216 /* Acer specific */
13217 /* bind volumes of both NID 0x02 and 0x03 */
13218 static const struct hda_bind_ctls alc268_acer_bind_master_vol = {
13219         .ops = &snd_hda_bind_vol,
13220         .values = {
13221                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
13222                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
13223                 0
13224         },
13225 };
13226
13227 static void alc268_acer_setup(struct hda_codec *codec)
13228 {
13229         struct alc_spec *spec = codec->spec;
13230
13231         spec->autocfg.hp_pins[0] = 0x14;
13232         spec->autocfg.speaker_pins[0] = 0x15;
13233         spec->automute = 1;
13234         spec->automute_mode = ALC_AUTOMUTE_AMP;
13235 }
13236
13237 #define alc268_acer_master_sw_get       alc262_hp_master_sw_get
13238 #define alc268_acer_master_sw_put       alc262_hp_master_sw_put
13239
13240 static const struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
13241         /* output mixer control */
13242         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13243         {
13244                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13245                 .name = "Master Playback Switch",
13246                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x15,
13247                 .info = snd_ctl_boolean_mono_info,
13248                 .get = alc268_acer_master_sw_get,
13249                 .put = alc268_acer_master_sw_put,
13250         },
13251         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
13252         { }
13253 };
13254
13255 static const struct snd_kcontrol_new alc268_acer_mixer[] = {
13256         /* output mixer control */
13257         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13258         {
13259                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13260                 .name = "Master Playback Switch",
13261                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x14,
13262                 .info = snd_ctl_boolean_mono_info,
13263                 .get = alc268_acer_master_sw_get,
13264                 .put = alc268_acer_master_sw_put,
13265         },
13266         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13267         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13268         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13269         { }
13270 };
13271
13272 static const struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
13273         /* output mixer control */
13274         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13275         {
13276                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13277                 .name = "Master Playback Switch",
13278                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x14,
13279                 .info = snd_ctl_boolean_mono_info,
13280                 .get = alc268_acer_master_sw_get,
13281                 .put = alc268_acer_master_sw_put,
13282         },
13283         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13284         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13285         { }
13286 };
13287
13288 static const struct hda_verb alc268_acer_aspire_one_verbs[] = {
13289         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13290         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13291         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13292         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13293         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
13294         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
13295         { }
13296 };
13297
13298 static const struct hda_verb alc268_acer_verbs[] = {
13299         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
13300         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13301         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13302         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13303         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13304         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13305         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13306         { }
13307 };
13308
13309 /* unsolicited event for HP jack sensing */
13310 #define alc268_toshiba_setup            alc262_hippo_setup
13311
13312 static void alc268_acer_lc_setup(struct hda_codec *codec)
13313 {
13314         struct alc_spec *spec = codec->spec;
13315         spec->autocfg.hp_pins[0] = 0x15;
13316         spec->autocfg.speaker_pins[0] = 0x14;
13317         spec->automute_mixer_nid[0] = 0x0f;
13318         spec->automute = 1;
13319         spec->automute_mode = ALC_AUTOMUTE_MIXER;
13320         spec->ext_mic.pin = 0x18;
13321         spec->ext_mic.mux_idx = 0;
13322         spec->int_mic.pin = 0x12;
13323         spec->int_mic.mux_idx = 6;
13324         spec->auto_mic = 1;
13325 }
13326
13327 static const struct snd_kcontrol_new alc268_dell_mixer[] = {
13328         /* output mixer control */
13329         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13330         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13331         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13332         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13333         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13334         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13335         { }
13336 };
13337
13338 static const struct hda_verb alc268_dell_verbs[] = {
13339         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13340         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13341         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13342         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13343         { }
13344 };
13345
13346 /* mute/unmute internal speaker according to the hp jack and mute state */
13347 static void alc268_dell_setup(struct hda_codec *codec)
13348 {
13349         struct alc_spec *spec = codec->spec;
13350
13351         spec->autocfg.hp_pins[0] = 0x15;
13352         spec->autocfg.speaker_pins[0] = 0x14;
13353         spec->ext_mic.pin = 0x18;
13354         spec->ext_mic.mux_idx = 0;
13355         spec->int_mic.pin = 0x19;
13356         spec->int_mic.mux_idx = 1;
13357         spec->auto_mic = 1;
13358         spec->automute = 1;
13359         spec->automute_mode = ALC_AUTOMUTE_PIN;
13360 }
13361
13362 static const struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
13363         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13364         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13365         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13366         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13367         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13368         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
13369         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13370         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13371         { }
13372 };
13373
13374 static const struct hda_verb alc267_quanta_il1_verbs[] = {
13375         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13376         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13377         { }
13378 };
13379
13380 static void alc267_quanta_il1_setup(struct hda_codec *codec)
13381 {
13382         struct alc_spec *spec = codec->spec;
13383         spec->autocfg.hp_pins[0] = 0x15;
13384         spec->autocfg.speaker_pins[0] = 0x14;
13385         spec->ext_mic.pin = 0x18;
13386         spec->ext_mic.mux_idx = 0;
13387         spec->int_mic.pin = 0x19;
13388         spec->int_mic.mux_idx = 1;
13389         spec->auto_mic = 1;
13390         spec->automute = 1;
13391         spec->automute_mode = ALC_AUTOMUTE_PIN;
13392 }
13393
13394 /*
13395  * generic initialization of ADC, input mixers and output mixers
13396  */
13397 static const struct hda_verb alc268_base_init_verbs[] = {
13398         /* Unmute DAC0-1 and set vol = 0 */
13399         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13400         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13401
13402         /*
13403          * Set up output mixers (0x0c - 0x0e)
13404          */
13405         /* set vol=0 to output mixers */
13406         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13407         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
13408
13409         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13410         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13411
13412         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13413         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
13414         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13415         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13416         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13417         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13418         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13419         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13420
13421         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13422         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13423         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13424         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13425         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13426
13427         /* set PCBEEP vol = 0, mute connections */
13428         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13429         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13430         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13431
13432         /* Unmute Selector 23h,24h and set the default input to mic-in */
13433
13434         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13435         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13436         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
13437         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13438
13439         { }
13440 };
13441
13442 /*
13443  * generic initialization of ADC, input mixers and output mixers
13444  */
13445 static const struct hda_verb alc268_volume_init_verbs[] = {
13446         /* set output DAC */
13447         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13448         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13449
13450         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13451         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13452         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13453         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13454         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13455
13456         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13457         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13458         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13459
13460         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13461         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13462
13463         /* set PCBEEP vol = 0, mute connections */
13464         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13465         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13466         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13467
13468         { }
13469 };
13470
13471 static const struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
13472         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13473         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13474         { } /* end */
13475 };
13476
13477 static const struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
13478         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13479         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13480         _DEFINE_CAPSRC(1),
13481         { } /* end */
13482 };
13483
13484 static const struct snd_kcontrol_new alc268_capture_mixer[] = {
13485         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13486         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13487         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
13488         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
13489         _DEFINE_CAPSRC(2),
13490         { } /* end */
13491 };
13492
13493 static const struct hda_input_mux alc268_capture_source = {
13494         .num_items = 4,
13495         .items = {
13496                 { "Mic", 0x0 },
13497                 { "Front Mic", 0x1 },
13498                 { "Line", 0x2 },
13499                 { "CD", 0x3 },
13500         },
13501 };
13502
13503 static const struct hda_input_mux alc268_acer_capture_source = {
13504         .num_items = 3,
13505         .items = {
13506                 { "Mic", 0x0 },
13507                 { "Internal Mic", 0x1 },
13508                 { "Line", 0x2 },
13509         },
13510 };
13511
13512 static const struct hda_input_mux alc268_acer_dmic_capture_source = {
13513         .num_items = 3,
13514         .items = {
13515                 { "Mic", 0x0 },
13516                 { "Internal Mic", 0x6 },
13517                 { "Line", 0x2 },
13518         },
13519 };
13520
13521 #ifdef CONFIG_SND_DEBUG
13522 static const struct snd_kcontrol_new alc268_test_mixer[] = {
13523         /* Volume widgets */
13524         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13525         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13526         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13527         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
13528         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
13529         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
13530         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
13531         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
13532         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
13533         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
13534         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
13535         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
13536         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
13537         /* The below appears problematic on some hardwares */
13538         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
13539         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13540         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
13541         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
13542         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
13543
13544         /* Modes for retasking pin widgets */
13545         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
13546         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
13547         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
13548         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
13549
13550         /* Controls for GPIO pins, assuming they are configured as outputs */
13551         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
13552         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
13553         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
13554         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
13555
13556         /* Switches to allow the digital SPDIF output pin to be enabled.
13557          * The ALC268 does not have an SPDIF input.
13558          */
13559         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
13560
13561         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
13562          * this output to turn on an external amplifier.
13563          */
13564         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
13565         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
13566
13567         { } /* end */
13568 };
13569 #endif
13570
13571 /* create input playback/capture controls for the given pin */
13572 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
13573                                     const char *ctlname, int idx)
13574 {
13575         hda_nid_t dac;
13576         int err;
13577
13578         switch (nid) {
13579         case 0x14:
13580         case 0x16:
13581                 dac = 0x02;
13582                 break;
13583         case 0x15:
13584         case 0x1a: /* ALC259/269 only */
13585         case 0x1b: /* ALC259/269 only */
13586         case 0x21: /* ALC269vb has this pin, too */
13587                 dac = 0x03;
13588                 break;
13589         default:
13590                 snd_printd(KERN_WARNING "hda_codec: "
13591                            "ignoring pin 0x%x as unknown\n", nid);
13592                 return 0;
13593         }
13594         if (spec->multiout.dac_nids[0] != dac &&
13595             spec->multiout.dac_nids[1] != dac) {
13596                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
13597                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
13598                                                       HDA_OUTPUT));
13599                 if (err < 0)
13600                         return err;
13601                 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
13602         }
13603
13604         if (nid != 0x16)
13605                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13606                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
13607         else /* mono */
13608                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13609                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
13610         if (err < 0)
13611                 return err;
13612         return 0;
13613 }
13614
13615 /* add playback controls from the parsed DAC table */
13616 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
13617                                              const struct auto_pin_cfg *cfg)
13618 {
13619         hda_nid_t nid;
13620         int err;
13621
13622         spec->multiout.dac_nids = spec->private_dac_nids;
13623
13624         nid = cfg->line_out_pins[0];
13625         if (nid) {
13626                 const char *name;
13627                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
13628                         name = "Speaker";
13629                 else
13630                         name = "Front";
13631                 err = alc268_new_analog_output(spec, nid, name, 0);
13632                 if (err < 0)
13633                         return err;
13634         }
13635
13636         nid = cfg->speaker_pins[0];
13637         if (nid == 0x1d) {
13638                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
13639                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
13640                 if (err < 0)
13641                         return err;
13642         } else if (nid) {
13643                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
13644                 if (err < 0)
13645                         return err;
13646         }
13647         nid = cfg->hp_pins[0];
13648         if (nid) {
13649                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
13650                 if (err < 0)
13651                         return err;
13652         }
13653
13654         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
13655         if (nid == 0x16) {
13656                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
13657                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
13658                 if (err < 0)
13659                         return err;
13660         }
13661         return 0;
13662 }
13663
13664 /* create playback/capture controls for input pins */
13665 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
13666                                                 const struct auto_pin_cfg *cfg)
13667 {
13668         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
13669 }
13670
13671 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
13672                                               hda_nid_t nid, int pin_type)
13673 {
13674         int idx;
13675
13676         alc_set_pin_output(codec, nid, pin_type);
13677         if (nid == 0x14 || nid == 0x16)
13678                 idx = 0;
13679         else
13680                 idx = 1;
13681         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
13682 }
13683
13684 static void alc268_auto_init_multi_out(struct hda_codec *codec)
13685 {
13686         struct alc_spec *spec = codec->spec;
13687         int i;
13688
13689         for (i = 0; i < spec->autocfg.line_outs; i++) {
13690                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13691                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13692                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
13693         }
13694 }
13695
13696 static void alc268_auto_init_hp_out(struct hda_codec *codec)
13697 {
13698         struct alc_spec *spec = codec->spec;
13699         hda_nid_t pin;
13700         int i;
13701
13702         for (i = 0; i < spec->autocfg.hp_outs; i++) {
13703                 pin = spec->autocfg.hp_pins[i];
13704                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
13705         }
13706         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
13707                 pin = spec->autocfg.speaker_pins[i];
13708                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
13709         }
13710         if (spec->autocfg.mono_out_pin)
13711                 snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0,
13712                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13713 }
13714
13715 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
13716 {
13717         struct alc_spec *spec = codec->spec;
13718         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
13719         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
13720         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
13721         unsigned int    dac_vol1, dac_vol2;
13722
13723         if (line_nid == 0x1d || speaker_nid == 0x1d) {
13724                 snd_hda_codec_write(codec, speaker_nid, 0,
13725                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13726                 /* mute mixer inputs from 0x1d */
13727                 snd_hda_codec_write(codec, 0x0f, 0,
13728                                     AC_VERB_SET_AMP_GAIN_MUTE,
13729                                     AMP_IN_UNMUTE(1));
13730                 snd_hda_codec_write(codec, 0x10, 0,
13731                                     AC_VERB_SET_AMP_GAIN_MUTE,
13732                                     AMP_IN_UNMUTE(1));
13733         } else {
13734                 /* unmute mixer inputs from 0x1d */
13735                 snd_hda_codec_write(codec, 0x0f, 0,
13736                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13737                 snd_hda_codec_write(codec, 0x10, 0,
13738                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13739         }
13740
13741         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
13742         if (line_nid == 0x14)
13743                 dac_vol2 = AMP_OUT_ZERO;
13744         else if (line_nid == 0x15)
13745                 dac_vol1 = AMP_OUT_ZERO;
13746         if (hp_nid == 0x14)
13747                 dac_vol2 = AMP_OUT_ZERO;
13748         else if (hp_nid == 0x15)
13749                 dac_vol1 = AMP_OUT_ZERO;
13750         if (line_nid != 0x16 || hp_nid != 0x16 ||
13751             spec->autocfg.line_out_pins[1] != 0x16 ||
13752             spec->autocfg.line_out_pins[2] != 0x16)
13753                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
13754
13755         snd_hda_codec_write(codec, 0x02, 0,
13756                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
13757         snd_hda_codec_write(codec, 0x03, 0,
13758                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
13759 }
13760
13761 /* pcm configuration: identical with ALC880 */
13762 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
13763 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
13764 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
13765 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
13766
13767 /*
13768  * BIOS auto configuration
13769  */
13770 static int alc268_parse_auto_config(struct hda_codec *codec)
13771 {
13772         struct alc_spec *spec = codec->spec;
13773         int err;
13774         static const hda_nid_t alc268_ignore[] = { 0 };
13775
13776         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13777                                            alc268_ignore);
13778         if (err < 0)
13779                 return err;
13780         if (!spec->autocfg.line_outs) {
13781                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13782                         spec->multiout.max_channels = 2;
13783                         spec->no_analog = 1;
13784                         goto dig_only;
13785                 }
13786                 return 0; /* can't find valid BIOS pin config */
13787         }
13788         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13789         if (err < 0)
13790                 return err;
13791         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13792         if (err < 0)
13793                 return err;
13794
13795         spec->multiout.max_channels = 2;
13796
13797  dig_only:
13798         /* digital only support output */
13799         alc_auto_parse_digital(codec);
13800         if (spec->kctls.list)
13801                 add_mixer(spec, spec->kctls.list);
13802
13803         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13804                 add_mixer(spec, alc268_beep_mixer);
13805
13806         add_verb(spec, alc268_volume_init_verbs);
13807         spec->num_mux_defs = 2;
13808         spec->input_mux = &spec->private_imux[0];
13809
13810         err = alc_auto_add_mic_boost(codec);
13811         if (err < 0)
13812                 return err;
13813
13814         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13815
13816         return 1;
13817 }
13818
13819 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
13820 #define alc268_auto_init_input_src      alc882_auto_init_input_src
13821
13822 /* init callback for auto-configuration model -- overriding the default init */
13823 static void alc268_auto_init(struct hda_codec *codec)
13824 {
13825         struct alc_spec *spec = codec->spec;
13826         alc268_auto_init_multi_out(codec);
13827         alc268_auto_init_hp_out(codec);
13828         alc268_auto_init_mono_speaker_out(codec);
13829         alc268_auto_init_analog_input(codec);
13830         alc268_auto_init_input_src(codec);
13831         alc_auto_init_digital(codec);
13832         if (spec->unsol_event)
13833                 alc_inithook(codec);
13834 }
13835
13836 /*
13837  * configuration and preset
13838  */
13839 static const char * const alc268_models[ALC268_MODEL_LAST] = {
13840         [ALC267_QUANTA_IL1]     = "quanta-il1",
13841         [ALC268_3ST]            = "3stack",
13842         [ALC268_TOSHIBA]        = "toshiba",
13843         [ALC268_ACER]           = "acer",
13844         [ALC268_ACER_DMIC]      = "acer-dmic",
13845         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
13846         [ALC268_DELL]           = "dell",
13847         [ALC268_ZEPTO]          = "zepto",
13848 #ifdef CONFIG_SND_DEBUG
13849         [ALC268_TEST]           = "test",
13850 #endif
13851         [ALC268_AUTO]           = "auto",
13852 };
13853
13854 static const struct snd_pci_quirk alc268_cfg_tbl[] = {
13855         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13856         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13857         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13858         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13859         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13860         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13861                                                 ALC268_ACER_ASPIRE_ONE),
13862         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13863         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron 910", ALC268_AUTO),
13864         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13865                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13866         /* almost compatible with toshiba but with optional digital outs;
13867          * auto-probing seems working fine
13868          */
13869         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13870                            ALC268_AUTO),
13871         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13872         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13873         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13874         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13875         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13876         {}
13877 };
13878
13879 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
13880 static const struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13881         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13882         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13883         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13884                            ALC268_TOSHIBA),
13885         {}
13886 };
13887
13888 static const struct alc_config_preset alc268_presets[] = {
13889         [ALC267_QUANTA_IL1] = {
13890                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13891                             alc268_capture_nosrc_mixer },
13892                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13893                                 alc267_quanta_il1_verbs },
13894                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13895                 .dac_nids = alc268_dac_nids,
13896                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13897                 .adc_nids = alc268_adc_nids_alt,
13898                 .hp_nid = 0x03,
13899                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13900                 .channel_mode = alc268_modes,
13901                 .unsol_event = alc_sku_unsol_event,
13902                 .setup = alc267_quanta_il1_setup,
13903                 .init_hook = alc_inithook,
13904         },
13905         [ALC268_3ST] = {
13906                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13907                             alc268_beep_mixer },
13908                 .init_verbs = { alc268_base_init_verbs },
13909                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13910                 .dac_nids = alc268_dac_nids,
13911                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13912                 .adc_nids = alc268_adc_nids_alt,
13913                 .capsrc_nids = alc268_capsrc_nids,
13914                 .hp_nid = 0x03,
13915                 .dig_out_nid = ALC268_DIGOUT_NID,
13916                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13917                 .channel_mode = alc268_modes,
13918                 .input_mux = &alc268_capture_source,
13919         },
13920         [ALC268_TOSHIBA] = {
13921                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13922                             alc268_beep_mixer },
13923                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13924                                 alc268_toshiba_verbs },
13925                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13926                 .dac_nids = alc268_dac_nids,
13927                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13928                 .adc_nids = alc268_adc_nids_alt,
13929                 .capsrc_nids = alc268_capsrc_nids,
13930                 .hp_nid = 0x03,
13931                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13932                 .channel_mode = alc268_modes,
13933                 .input_mux = &alc268_capture_source,
13934                 .unsol_event = alc_sku_unsol_event,
13935                 .setup = alc268_toshiba_setup,
13936                 .init_hook = alc_inithook,
13937         },
13938         [ALC268_ACER] = {
13939                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13940                             alc268_beep_mixer },
13941                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13942                                 alc268_acer_verbs },
13943                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13944                 .dac_nids = alc268_dac_nids,
13945                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13946                 .adc_nids = alc268_adc_nids_alt,
13947                 .capsrc_nids = alc268_capsrc_nids,
13948                 .hp_nid = 0x02,
13949                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13950                 .channel_mode = alc268_modes,
13951                 .input_mux = &alc268_acer_capture_source,
13952                 .unsol_event = alc_sku_unsol_event,
13953                 .setup = alc268_acer_setup,
13954                 .init_hook = alc_inithook,
13955         },
13956         [ALC268_ACER_DMIC] = {
13957                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13958                             alc268_beep_mixer },
13959                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13960                                 alc268_acer_verbs },
13961                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13962                 .dac_nids = alc268_dac_nids,
13963                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13964                 .adc_nids = alc268_adc_nids_alt,
13965                 .capsrc_nids = alc268_capsrc_nids,
13966                 .hp_nid = 0x02,
13967                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13968                 .channel_mode = alc268_modes,
13969                 .input_mux = &alc268_acer_dmic_capture_source,
13970                 .unsol_event = alc_sku_unsol_event,
13971                 .setup = alc268_acer_setup,
13972                 .init_hook = alc_inithook,
13973         },
13974         [ALC268_ACER_ASPIRE_ONE] = {
13975                 .mixers = { alc268_acer_aspire_one_mixer,
13976                             alc268_beep_mixer,
13977                             alc268_capture_nosrc_mixer },
13978                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13979                                 alc268_acer_aspire_one_verbs },
13980                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13981                 .dac_nids = alc268_dac_nids,
13982                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13983                 .adc_nids = alc268_adc_nids_alt,
13984                 .capsrc_nids = alc268_capsrc_nids,
13985                 .hp_nid = 0x03,
13986                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13987                 .channel_mode = alc268_modes,
13988                 .unsol_event = alc_sku_unsol_event,
13989                 .setup = alc268_acer_lc_setup,
13990                 .init_hook = alc_inithook,
13991         },
13992         [ALC268_DELL] = {
13993                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
13994                             alc268_capture_nosrc_mixer },
13995                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13996                                 alc268_dell_verbs },
13997                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13998                 .dac_nids = alc268_dac_nids,
13999                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
14000                 .adc_nids = alc268_adc_nids_alt,
14001                 .capsrc_nids = alc268_capsrc_nids,
14002                 .hp_nid = 0x02,
14003                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
14004                 .channel_mode = alc268_modes,
14005                 .unsol_event = alc_sku_unsol_event,
14006                 .setup = alc268_dell_setup,
14007                 .init_hook = alc_inithook,
14008         },
14009         [ALC268_ZEPTO] = {
14010                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
14011                             alc268_beep_mixer },
14012                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
14013                                 alc268_toshiba_verbs },
14014                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
14015                 .dac_nids = alc268_dac_nids,
14016                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
14017                 .adc_nids = alc268_adc_nids_alt,
14018                 .capsrc_nids = alc268_capsrc_nids,
14019                 .hp_nid = 0x03,
14020                 .dig_out_nid = ALC268_DIGOUT_NID,
14021                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
14022                 .channel_mode = alc268_modes,
14023                 .input_mux = &alc268_capture_source,
14024                 .unsol_event = alc_sku_unsol_event,
14025                 .setup = alc268_toshiba_setup,
14026                 .init_hook = alc_inithook,
14027         },
14028 #ifdef CONFIG_SND_DEBUG
14029         [ALC268_TEST] = {
14030                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
14031                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
14032                                 alc268_volume_init_verbs },
14033                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
14034                 .dac_nids = alc268_dac_nids,
14035                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
14036                 .adc_nids = alc268_adc_nids_alt,
14037                 .capsrc_nids = alc268_capsrc_nids,
14038                 .hp_nid = 0x03,
14039                 .dig_out_nid = ALC268_DIGOUT_NID,
14040                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
14041                 .channel_mode = alc268_modes,
14042                 .input_mux = &alc268_capture_source,
14043         },
14044 #endif
14045 };
14046
14047 static int patch_alc268(struct hda_codec *codec)
14048 {
14049         struct alc_spec *spec;
14050         int board_config;
14051         int i, has_beep, err;
14052
14053         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14054         if (spec == NULL)
14055                 return -ENOMEM;
14056
14057         codec->spec = spec;
14058
14059         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
14060                                                   alc268_models,
14061                                                   alc268_cfg_tbl);
14062
14063         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
14064                 board_config = snd_hda_check_board_codec_sid_config(codec,
14065                         ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
14066
14067         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
14068                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14069                        codec->chip_name);
14070                 board_config = ALC268_AUTO;
14071         }
14072
14073         if (board_config == ALC268_AUTO) {
14074                 /* automatic parse from the BIOS config */
14075                 err = alc268_parse_auto_config(codec);
14076                 if (err < 0) {
14077                         alc_free(codec);
14078                         return err;
14079                 } else if (!err) {
14080                         printk(KERN_INFO
14081                                "hda_codec: Cannot set up configuration "
14082                                "from BIOS.  Using base mode...\n");
14083                         board_config = ALC268_3ST;
14084                 }
14085         }
14086
14087         if (board_config != ALC268_AUTO)
14088                 setup_preset(codec, &alc268_presets[board_config]);
14089
14090         spec->stream_analog_playback = &alc268_pcm_analog_playback;
14091         spec->stream_analog_capture = &alc268_pcm_analog_capture;
14092         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
14093
14094         spec->stream_digital_playback = &alc268_pcm_digital_playback;
14095
14096         has_beep = 0;
14097         for (i = 0; i < spec->num_mixers; i++) {
14098                 if (spec->mixers[i] == alc268_beep_mixer) {
14099                         has_beep = 1;
14100                         break;
14101                 }
14102         }
14103
14104         if (has_beep) {
14105                 err = snd_hda_attach_beep_device(codec, 0x1);
14106                 if (err < 0) {
14107                         alc_free(codec);
14108                         return err;
14109                 }
14110                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
14111                         /* override the amp caps for beep generator */
14112                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
14113                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
14114                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
14115                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
14116                                           (0 << AC_AMPCAP_MUTE_SHIFT));
14117         }
14118
14119         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
14120                 /* check whether NID 0x07 is valid */
14121                 unsigned int wcap = get_wcaps(codec, 0x07);
14122
14123                 spec->capsrc_nids = alc268_capsrc_nids;
14124                 /* get type */
14125                 wcap = get_wcaps_type(wcap);
14126                 if (spec->auto_mic ||
14127                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
14128                         spec->adc_nids = alc268_adc_nids_alt;
14129                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
14130                         if (spec->auto_mic)
14131                                 fixup_automic_adc(codec);
14132                         if (spec->auto_mic || spec->input_mux->num_items == 1)
14133                                 add_mixer(spec, alc268_capture_nosrc_mixer);
14134                         else
14135                                 add_mixer(spec, alc268_capture_alt_mixer);
14136                 } else {
14137                         spec->adc_nids = alc268_adc_nids;
14138                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
14139                         add_mixer(spec, alc268_capture_mixer);
14140                 }
14141         }
14142
14143         spec->vmaster_nid = 0x02;
14144
14145         codec->patch_ops = alc_patch_ops;
14146         if (board_config == ALC268_AUTO)
14147                 spec->init_hook = alc268_auto_init;
14148         spec->shutup = alc_eapd_shutup;
14149
14150         alc_init_jacks(codec);
14151
14152         return 0;
14153 }
14154
14155 /*
14156  *  ALC269 channel source setting (2 channel)
14157  */
14158 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
14159
14160 #define alc269_dac_nids         alc260_dac_nids
14161
14162 static const hda_nid_t alc269_adc_nids[1] = {
14163         /* ADC1 */
14164         0x08,
14165 };
14166
14167 static const hda_nid_t alc269_capsrc_nids[1] = {
14168         0x23,
14169 };
14170
14171 static const hda_nid_t alc269vb_adc_nids[1] = {
14172         /* ADC1 */
14173         0x09,
14174 };
14175
14176 static const hda_nid_t alc269vb_capsrc_nids[1] = {
14177         0x22,
14178 };
14179
14180 static const hda_nid_t alc269_adc_candidates[] = {
14181         0x08, 0x09, 0x07, 0x11,
14182 };
14183
14184 #define alc269_modes            alc260_modes
14185 #define alc269_capture_source   alc880_lg_lw_capture_source
14186
14187 static const struct snd_kcontrol_new alc269_base_mixer[] = {
14188         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14189         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14190         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14191         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14192         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14193         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14194         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14195         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14196         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14197         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
14198         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14199         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
14200         { } /* end */
14201 };
14202
14203 static const struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
14204         /* output mixer control */
14205         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14206         {
14207                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14208                 .name = "Master Playback Switch",
14209                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14210                 .info = snd_hda_mixer_amp_switch_info,
14211                 .get = snd_hda_mixer_amp_switch_get,
14212                 .put = alc268_acer_master_sw_put,
14213                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14214         },
14215         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14216         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14217         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14218         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14219         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14220         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14221         { }
14222 };
14223
14224 static const struct snd_kcontrol_new alc269_lifebook_mixer[] = {
14225         /* output mixer control */
14226         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14227         {
14228                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14229                 .name = "Master Playback Switch",
14230                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14231                 .info = snd_hda_mixer_amp_switch_info,
14232                 .get = snd_hda_mixer_amp_switch_get,
14233                 .put = alc268_acer_master_sw_put,
14234                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14235         },
14236         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14237         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14238         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14239         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14240         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14241         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14242         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
14243         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
14244         HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x1b, 0, HDA_INPUT),
14245         { }
14246 };
14247
14248 static const struct snd_kcontrol_new alc269_laptop_mixer[] = {
14249         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14250         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14251         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14252         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14253         { } /* end */
14254 };
14255
14256 static const struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
14257         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14258         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14259         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14260         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14261         { } /* end */
14262 };
14263
14264 static const struct snd_kcontrol_new alc269_asus_mixer[] = {
14265         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14266         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
14267         { } /* end */
14268 };
14269
14270 /* capture mixer elements */
14271 static const struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
14272         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14273         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14274         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14275         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14276         { } /* end */
14277 };
14278
14279 static const struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
14280         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14281         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14282         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14283         { } /* end */
14284 };
14285
14286 static const struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
14287         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14288         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14289         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14290         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14291         { } /* end */
14292 };
14293
14294 static const struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
14295         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14296         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14297         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14298         { } /* end */
14299 };
14300
14301 /* FSC amilo */
14302 #define alc269_fujitsu_mixer    alc269_laptop_mixer
14303
14304 static const struct hda_verb alc269_quanta_fl1_verbs[] = {
14305         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14306         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14307         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14308         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14309         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14310         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14311         { }
14312 };
14313
14314 static const struct hda_verb alc269_lifebook_verbs[] = {
14315         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14316         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
14317         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14318         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14319         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14320         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14321         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14322         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14323         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14324         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14325         { }
14326 };
14327
14328 /* toggle speaker-output according to the hp-jack state */
14329 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
14330 {
14331         alc_hp_automute(codec);
14332
14333         snd_hda_codec_write(codec, 0x20, 0,
14334                         AC_VERB_SET_COEF_INDEX, 0x0c);
14335         snd_hda_codec_write(codec, 0x20, 0,
14336                         AC_VERB_SET_PROC_COEF, 0x680);
14337
14338         snd_hda_codec_write(codec, 0x20, 0,
14339                         AC_VERB_SET_COEF_INDEX, 0x0c);
14340         snd_hda_codec_write(codec, 0x20, 0,
14341                         AC_VERB_SET_PROC_COEF, 0x480);
14342 }
14343
14344 #define alc269_lifebook_speaker_automute \
14345         alc269_quanta_fl1_speaker_automute
14346
14347 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
14348 {
14349         unsigned int present_laptop;
14350         unsigned int present_dock;
14351
14352         present_laptop  = snd_hda_jack_detect(codec, 0x18);
14353         present_dock    = snd_hda_jack_detect(codec, 0x1b);
14354
14355         /* Laptop mic port overrides dock mic port, design decision */
14356         if (present_dock)
14357                 snd_hda_codec_write(codec, 0x23, 0,
14358                                 AC_VERB_SET_CONNECT_SEL, 0x3);
14359         if (present_laptop)
14360                 snd_hda_codec_write(codec, 0x23, 0,
14361                                 AC_VERB_SET_CONNECT_SEL, 0x0);
14362         if (!present_dock && !present_laptop)
14363                 snd_hda_codec_write(codec, 0x23, 0,
14364                                 AC_VERB_SET_CONNECT_SEL, 0x1);
14365 }
14366
14367 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
14368                                     unsigned int res)
14369 {
14370         switch (res >> 26) {
14371         case ALC880_HP_EVENT:
14372                 alc269_quanta_fl1_speaker_automute(codec);
14373                 break;
14374         case ALC880_MIC_EVENT:
14375                 alc_mic_automute(codec);
14376                 break;
14377         }
14378 }
14379
14380 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
14381                                         unsigned int res)
14382 {
14383         if ((res >> 26) == ALC880_HP_EVENT)
14384                 alc269_lifebook_speaker_automute(codec);
14385         if ((res >> 26) == ALC880_MIC_EVENT)
14386                 alc269_lifebook_mic_autoswitch(codec);
14387 }
14388
14389 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
14390 {
14391         struct alc_spec *spec = codec->spec;
14392         spec->autocfg.hp_pins[0] = 0x15;
14393         spec->autocfg.speaker_pins[0] = 0x14;
14394         spec->automute_mixer_nid[0] = 0x0c;
14395         spec->automute = 1;
14396         spec->automute_mode = ALC_AUTOMUTE_MIXER;
14397         spec->ext_mic.pin = 0x18;
14398         spec->ext_mic.mux_idx = 0;
14399         spec->int_mic.pin = 0x19;
14400         spec->int_mic.mux_idx = 1;
14401         spec->auto_mic = 1;
14402 }
14403
14404 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
14405 {
14406         alc269_quanta_fl1_speaker_automute(codec);
14407         alc_mic_automute(codec);
14408 }
14409
14410 static void alc269_lifebook_setup(struct hda_codec *codec)
14411 {
14412         struct alc_spec *spec = codec->spec;
14413         spec->autocfg.hp_pins[0] = 0x15;
14414         spec->autocfg.hp_pins[1] = 0x1a;
14415         spec->autocfg.speaker_pins[0] = 0x14;
14416         spec->automute_mixer_nid[0] = 0x0c;
14417         spec->automute = 1;
14418         spec->automute_mode = ALC_AUTOMUTE_MIXER;
14419 }
14420
14421 static void alc269_lifebook_init_hook(struct hda_codec *codec)
14422 {
14423         alc269_lifebook_speaker_automute(codec);
14424         alc269_lifebook_mic_autoswitch(codec);
14425 }
14426
14427 static const struct hda_verb alc269_laptop_dmic_init_verbs[] = {
14428         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14429         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
14430         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14431         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14432         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14433         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14434         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14435         {}
14436 };
14437
14438 static const struct hda_verb alc269_laptop_amic_init_verbs[] = {
14439         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14440         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
14441         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14442         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
14443         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14444         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14445         {}
14446 };
14447
14448 static const struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
14449         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14450         {0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
14451         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14452         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14453         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14454         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14455         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14456         {}
14457 };
14458
14459 static const struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
14460         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14461         {0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
14462         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14463         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14464         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14465         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14466         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14467         {}
14468 };
14469
14470 static const struct hda_verb alc271_acer_dmic_verbs[] = {
14471         {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14472         {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14473         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14474         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14475         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14476         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14477         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
14478         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14479         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14480         {0x22, AC_VERB_SET_CONNECT_SEL, 6},
14481         { }
14482 };
14483
14484 static void alc269_laptop_amic_setup(struct hda_codec *codec)
14485 {
14486         struct alc_spec *spec = codec->spec;
14487         spec->autocfg.hp_pins[0] = 0x15;
14488         spec->autocfg.speaker_pins[0] = 0x14;
14489         spec->automute_mixer_nid[0] = 0x0c;
14490         spec->automute = 1;
14491         spec->automute_mode = ALC_AUTOMUTE_MIXER;
14492         spec->ext_mic.pin = 0x18;
14493         spec->ext_mic.mux_idx = 0;
14494         spec->int_mic.pin = 0x19;
14495         spec->int_mic.mux_idx = 1;
14496         spec->auto_mic = 1;
14497 }
14498
14499 static void alc269_laptop_dmic_setup(struct hda_codec *codec)
14500 {
14501         struct alc_spec *spec = codec->spec;
14502         spec->autocfg.hp_pins[0] = 0x15;
14503         spec->autocfg.speaker_pins[0] = 0x14;
14504         spec->automute_mixer_nid[0] = 0x0c;
14505         spec->automute = 1;
14506         spec->automute_mode = ALC_AUTOMUTE_MIXER;
14507         spec->ext_mic.pin = 0x18;
14508         spec->ext_mic.mux_idx = 0;
14509         spec->int_mic.pin = 0x12;
14510         spec->int_mic.mux_idx = 5;
14511         spec->auto_mic = 1;
14512 }
14513
14514 static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
14515 {
14516         struct alc_spec *spec = codec->spec;
14517         spec->autocfg.hp_pins[0] = 0x21;
14518         spec->autocfg.speaker_pins[0] = 0x14;
14519         spec->automute_mixer_nid[0] = 0x0c;
14520         spec->automute = 1;
14521         spec->automute_mode = ALC_AUTOMUTE_MIXER;
14522         spec->ext_mic.pin = 0x18;
14523         spec->ext_mic.mux_idx = 0;
14524         spec->int_mic.pin = 0x19;
14525         spec->int_mic.mux_idx = 1;
14526         spec->auto_mic = 1;
14527 }
14528
14529 static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
14530 {
14531         struct alc_spec *spec = codec->spec;
14532         spec->autocfg.hp_pins[0] = 0x21;
14533         spec->autocfg.speaker_pins[0] = 0x14;
14534         spec->automute_mixer_nid[0] = 0x0c;
14535         spec->automute = 1;
14536         spec->automute_mode = ALC_AUTOMUTE_MIXER;
14537         spec->ext_mic.pin = 0x18;
14538         spec->ext_mic.mux_idx = 0;
14539         spec->int_mic.pin = 0x12;
14540         spec->int_mic.mux_idx = 6;
14541         spec->auto_mic = 1;
14542 }
14543
14544 /*
14545  * generic initialization of ADC, input mixers and output mixers
14546  */
14547 static const struct hda_verb alc269_init_verbs[] = {
14548         /*
14549          * Unmute ADC0 and set the default input to mic-in
14550          */
14551         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14552
14553         /*
14554          * Set up output mixers (0x02 - 0x03)
14555          */
14556         /* set vol=0 to output mixers */
14557         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14558         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14559
14560         /* set up input amps for analog loopback */
14561         /* Amp Indices: DAC = 0, mixer = 1 */
14562         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14563         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14564         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14565         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14566         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14567         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14568
14569         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14570         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14571         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14572         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14573         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14574         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14575         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14576
14577         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14578         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14579
14580         /* FIXME: use Mux-type input source selection */
14581         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14582         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14583         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
14584
14585         /* set EAPD */
14586         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14587         { }
14588 };
14589
14590 static const struct hda_verb alc269vb_init_verbs[] = {
14591         /*
14592          * Unmute ADC0 and set the default input to mic-in
14593          */
14594         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14595
14596         /*
14597          * Set up output mixers (0x02 - 0x03)
14598          */
14599         /* set vol=0 to output mixers */
14600         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14601         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14602
14603         /* set up input amps for analog loopback */
14604         /* Amp Indices: DAC = 0, mixer = 1 */
14605         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14606         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14607         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14608         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14609         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14610         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14611
14612         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14613         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14614         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14615         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14616         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14617         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14618         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14619
14620         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14621         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14622
14623         /* FIXME: use Mux-type input source selection */
14624         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14625         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14626         {0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
14627
14628         /* set EAPD */
14629         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14630         { }
14631 };
14632
14633 #define alc269_auto_create_multi_out_ctls \
14634         alc268_auto_create_multi_out_ctls
14635 #define alc269_auto_create_input_ctls \
14636         alc268_auto_create_input_ctls
14637
14638 #ifdef CONFIG_SND_HDA_POWER_SAVE
14639 #define alc269_loopbacks        alc880_loopbacks
14640 #endif
14641
14642 /* pcm configuration: identical with ALC880 */
14643 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
14644 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
14645 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
14646 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
14647
14648 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
14649         .substreams = 1,
14650         .channels_min = 2,
14651         .channels_max = 8,
14652         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14653         /* NID is set in alc_build_pcms */
14654         .ops = {
14655                 .open = alc880_playback_pcm_open,
14656                 .prepare = alc880_playback_pcm_prepare,
14657                 .cleanup = alc880_playback_pcm_cleanup
14658         },
14659 };
14660
14661 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
14662         .substreams = 1,
14663         .channels_min = 2,
14664         .channels_max = 2,
14665         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14666         /* NID is set in alc_build_pcms */
14667 };
14668
14669 #ifdef CONFIG_SND_HDA_POWER_SAVE
14670 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
14671 {
14672         switch (codec->subsystem_id) {
14673         case 0x103c1586:
14674                 return 1;
14675         }
14676         return 0;
14677 }
14678
14679 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
14680 {
14681         /* update mute-LED according to the speaker mute state */
14682         if (nid == 0x01 || nid == 0x14) {
14683                 int pinval;
14684                 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
14685                     HDA_AMP_MUTE)
14686                         pinval = 0x24;
14687                 else
14688                         pinval = 0x20;
14689                 /* mic2 vref pin is used for mute LED control */
14690                 snd_hda_codec_update_cache(codec, 0x19, 0,
14691                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
14692                                            pinval);
14693         }
14694         return alc_check_power_status(codec, nid);
14695 }
14696 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14697
14698 static int alc275_setup_dual_adc(struct hda_codec *codec)
14699 {
14700         struct alc_spec *spec = codec->spec;
14701
14702         if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
14703                 return 0;
14704         if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
14705             (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
14706                 if (spec->ext_mic.pin <= 0x12) {
14707                         spec->private_adc_nids[0] = 0x08;
14708                         spec->private_adc_nids[1] = 0x11;
14709                         spec->private_capsrc_nids[0] = 0x23;
14710                         spec->private_capsrc_nids[1] = 0x22;
14711                 } else {
14712                         spec->private_adc_nids[0] = 0x11;
14713                         spec->private_adc_nids[1] = 0x08;
14714                         spec->private_capsrc_nids[0] = 0x22;
14715                         spec->private_capsrc_nids[1] = 0x23;
14716                 }
14717                 spec->adc_nids = spec->private_adc_nids;
14718                 spec->capsrc_nids = spec->private_capsrc_nids;
14719                 spec->num_adc_nids = 2;
14720                 spec->dual_adc_switch = 1;
14721                 snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
14722                             spec->adc_nids[0], spec->adc_nids[1]);
14723                 return 1;
14724         }
14725         return 0;
14726 }
14727
14728 /* different alc269-variants */
14729 enum {
14730         ALC269_TYPE_NORMAL,
14731         ALC269_TYPE_ALC258,
14732         ALC269_TYPE_ALC259,
14733         ALC269_TYPE_ALC269VB,
14734         ALC269_TYPE_ALC270,
14735         ALC269_TYPE_ALC271X,
14736 };
14737
14738 /*
14739  * BIOS auto configuration
14740  */
14741 static int alc269_parse_auto_config(struct hda_codec *codec)
14742 {
14743         struct alc_spec *spec = codec->spec;
14744         int err;
14745         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
14746
14747         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14748                                            alc269_ignore);
14749         if (err < 0)
14750                 return err;
14751
14752         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
14753         if (err < 0)
14754                 return err;
14755         if (spec->codec_variant == ALC269_TYPE_NORMAL)
14756                 err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
14757         else
14758                 err = alc_auto_create_input_ctls(codec, &spec->autocfg, 0,
14759                                                  0x22, 0);
14760         if (err < 0)
14761                 return err;
14762
14763         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14764
14765         alc_auto_parse_digital(codec);
14766
14767         if (spec->kctls.list)
14768                 add_mixer(spec, spec->kctls.list);
14769
14770         if (spec->codec_variant != ALC269_TYPE_NORMAL) {
14771                 add_verb(spec, alc269vb_init_verbs);
14772                 alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
14773         } else {
14774                 add_verb(spec, alc269_init_verbs);
14775                 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
14776         }
14777
14778         spec->num_mux_defs = 1;
14779         spec->input_mux = &spec->private_imux[0];
14780
14781         if (!alc275_setup_dual_adc(codec))
14782                 fillup_priv_adc_nids(codec, alc269_adc_candidates,
14783                                      sizeof(alc269_adc_candidates));
14784
14785         err = alc_auto_add_mic_boost(codec);
14786         if (err < 0)
14787                 return err;
14788
14789         if (!spec->cap_mixer && !spec->no_analog)
14790                 set_capture_mixer(codec);
14791
14792         return 1;
14793 }
14794
14795 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
14796 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
14797 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
14798 #define alc269_auto_init_input_src      alc882_auto_init_input_src
14799
14800
14801 /* init callback for auto-configuration model -- overriding the default init */
14802 static void alc269_auto_init(struct hda_codec *codec)
14803 {
14804         struct alc_spec *spec = codec->spec;
14805         alc269_auto_init_multi_out(codec);
14806         alc269_auto_init_hp_out(codec);
14807         alc269_auto_init_analog_input(codec);
14808         if (!spec->dual_adc_switch)
14809                 alc269_auto_init_input_src(codec);
14810         alc_auto_init_digital(codec);
14811         if (spec->unsol_event)
14812                 alc_inithook(codec);
14813 }
14814
14815 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
14816 {
14817         int val = alc_read_coef_idx(codec, 0x04);
14818         if (power_up)
14819                 val |= 1 << 11;
14820         else
14821                 val &= ~(1 << 11);
14822         alc_write_coef_idx(codec, 0x04, val);
14823 }
14824
14825 static void alc269_shutup(struct hda_codec *codec)
14826 {
14827         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
14828                 alc269_toggle_power_output(codec, 0);
14829         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14830                 alc269_toggle_power_output(codec, 0);
14831                 msleep(150);
14832         }
14833 }
14834
14835 #ifdef SND_HDA_NEEDS_RESUME
14836 static int alc269_resume(struct hda_codec *codec)
14837 {
14838         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14839                 alc269_toggle_power_output(codec, 0);
14840                 msleep(150);
14841         }
14842
14843         codec->patch_ops.init(codec);
14844
14845         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14846                 alc269_toggle_power_output(codec, 1);
14847                 msleep(200);
14848         }
14849
14850         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
14851                 alc269_toggle_power_output(codec, 1);
14852
14853         snd_hda_codec_resume_amp(codec);
14854         snd_hda_codec_resume_cache(codec);
14855         hda_call_check_power_status(codec, 0x01);
14856         return 0;
14857 }
14858 #endif /* SND_HDA_NEEDS_RESUME */
14859
14860 static void alc269_fixup_hweq(struct hda_codec *codec,
14861                                const struct alc_fixup *fix, int action)
14862 {
14863         int coef;
14864
14865         if (action != ALC_FIXUP_ACT_INIT)
14866                 return;
14867         coef = alc_read_coef_idx(codec, 0x1e);
14868         alc_write_coef_idx(codec, 0x1e, coef | 0x80);
14869 }
14870
14871 static void alc271_fixup_dmic(struct hda_codec *codec,
14872                               const struct alc_fixup *fix, int action)
14873 {
14874         static const struct hda_verb verbs[] = {
14875                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14876                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14877                 {}
14878         };
14879         unsigned int cfg;
14880
14881         if (strcmp(codec->chip_name, "ALC271X"))
14882                 return;
14883         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
14884         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
14885                 snd_hda_sequence_write(codec, verbs);
14886 }
14887
14888 enum {
14889         ALC269_FIXUP_SONY_VAIO,
14890         ALC275_FIXUP_SONY_VAIO_GPIO2,
14891         ALC269_FIXUP_DELL_M101Z,
14892         ALC269_FIXUP_SKU_IGNORE,
14893         ALC269_FIXUP_ASUS_G73JW,
14894         ALC269_FIXUP_LENOVO_EAPD,
14895         ALC275_FIXUP_SONY_HWEQ,
14896         ALC271_FIXUP_DMIC,
14897 };
14898
14899 static const struct alc_fixup alc269_fixups[] = {
14900         [ALC269_FIXUP_SONY_VAIO] = {
14901                 .type = ALC_FIXUP_VERBS,
14902                 .v.verbs = (const struct hda_verb[]) {
14903                         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14904                         {}
14905                 }
14906         },
14907         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
14908                 .type = ALC_FIXUP_VERBS,
14909                 .v.verbs = (const struct hda_verb[]) {
14910                         {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
14911                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
14912                         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
14913                         { }
14914                 },
14915                 .chained = true,
14916                 .chain_id = ALC269_FIXUP_SONY_VAIO
14917         },
14918         [ALC269_FIXUP_DELL_M101Z] = {
14919                 .type = ALC_FIXUP_VERBS,
14920                 .v.verbs = (const struct hda_verb[]) {
14921                         /* Enables internal speaker */
14922                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
14923                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
14924                         {}
14925                 }
14926         },
14927         [ALC269_FIXUP_SKU_IGNORE] = {
14928                 .type = ALC_FIXUP_SKU,
14929                 .v.sku = ALC_FIXUP_SKU_IGNORE,
14930         },
14931         [ALC269_FIXUP_ASUS_G73JW] = {
14932                 .type = ALC_FIXUP_PINS,
14933                 .v.pins = (const struct alc_pincfg[]) {
14934                         { 0x17, 0x99130111 }, /* subwoofer */
14935                         { }
14936                 }
14937         },
14938         [ALC269_FIXUP_LENOVO_EAPD] = {
14939                 .type = ALC_FIXUP_VERBS,
14940                 .v.verbs = (const struct hda_verb[]) {
14941                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
14942                         {}
14943                 }
14944         },
14945         [ALC275_FIXUP_SONY_HWEQ] = {
14946                 .type = ALC_FIXUP_FUNC,
14947                 .v.func = alc269_fixup_hweq,
14948                 .chained = true,
14949                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
14950         },
14951         [ALC271_FIXUP_DMIC] = {
14952                 .type = ALC_FIXUP_FUNC,
14953                 .v.func = alc271_fixup_dmic,
14954         },
14955 };
14956
14957 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
14958         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
14959         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
14960         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
14961         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14962         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
14963         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
14964         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
14965         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
14966         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
14967         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
14968         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
14969         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
14970         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
14971         {}
14972 };
14973
14974
14975 /*
14976  * configuration and preset
14977  */
14978 static const char * const alc269_models[ALC269_MODEL_LAST] = {
14979         [ALC269_BASIC]                  = "basic",
14980         [ALC269_QUANTA_FL1]             = "quanta",
14981         [ALC269_AMIC]                   = "laptop-amic",
14982         [ALC269_DMIC]                   = "laptop-dmic",
14983         [ALC269_FUJITSU]                = "fujitsu",
14984         [ALC269_LIFEBOOK]               = "lifebook",
14985         [ALC269_AUTO]                   = "auto",
14986 };
14987
14988 static const struct snd_pci_quirk alc269_cfg_tbl[] = {
14989         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
14990         SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
14991         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
14992                       ALC269_AMIC),
14993         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
14994         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
14995         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
14996         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
14997         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
14998         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
14999         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
15000         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
15001         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
15002         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269VB_AMIC),
15003         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
15004         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
15005         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
15006         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
15007         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
15008         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
15009         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
15010         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
15011         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
15012         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
15013         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
15014         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
15015         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
15016         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
15017         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
15018         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
15019         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
15020         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
15021         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
15022         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
15023         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
15024         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
15025         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
15026         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
15027         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
15028         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
15029         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
15030                       ALC269_DMIC),
15031         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
15032                       ALC269_DMIC),
15033         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
15034         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
15035         SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
15036         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
15037         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
15038         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
15039         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
15040         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
15041         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
15042         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
15043         {}
15044 };
15045
15046 static const struct alc_config_preset alc269_presets[] = {
15047         [ALC269_BASIC] = {
15048                 .mixers = { alc269_base_mixer },
15049                 .init_verbs = { alc269_init_verbs },
15050                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15051                 .dac_nids = alc269_dac_nids,
15052                 .hp_nid = 0x03,
15053                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15054                 .channel_mode = alc269_modes,
15055                 .input_mux = &alc269_capture_source,
15056         },
15057         [ALC269_QUANTA_FL1] = {
15058                 .mixers = { alc269_quanta_fl1_mixer },
15059                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
15060                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15061                 .dac_nids = alc269_dac_nids,
15062                 .hp_nid = 0x03,
15063                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15064                 .channel_mode = alc269_modes,
15065                 .input_mux = &alc269_capture_source,
15066                 .unsol_event = alc269_quanta_fl1_unsol_event,
15067                 .setup = alc269_quanta_fl1_setup,
15068                 .init_hook = alc269_quanta_fl1_init_hook,
15069         },
15070         [ALC269_AMIC] = {
15071                 .mixers = { alc269_laptop_mixer },
15072                 .cap_mixer = alc269_laptop_analog_capture_mixer,
15073                 .init_verbs = { alc269_init_verbs,
15074                                 alc269_laptop_amic_init_verbs },
15075                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15076                 .dac_nids = alc269_dac_nids,
15077                 .hp_nid = 0x03,
15078                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15079                 .channel_mode = alc269_modes,
15080                 .unsol_event = alc_sku_unsol_event,
15081                 .setup = alc269_laptop_amic_setup,
15082                 .init_hook = alc_inithook,
15083         },
15084         [ALC269_DMIC] = {
15085                 .mixers = { alc269_laptop_mixer },
15086                 .cap_mixer = alc269_laptop_digital_capture_mixer,
15087                 .init_verbs = { alc269_init_verbs,
15088                                 alc269_laptop_dmic_init_verbs },
15089                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15090                 .dac_nids = alc269_dac_nids,
15091                 .hp_nid = 0x03,
15092                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15093                 .channel_mode = alc269_modes,
15094                 .unsol_event = alc_sku_unsol_event,
15095                 .setup = alc269_laptop_dmic_setup,
15096                 .init_hook = alc_inithook,
15097         },
15098         [ALC269VB_AMIC] = {
15099                 .mixers = { alc269vb_laptop_mixer },
15100                 .cap_mixer = alc269vb_laptop_analog_capture_mixer,
15101                 .init_verbs = { alc269vb_init_verbs,
15102                                 alc269vb_laptop_amic_init_verbs },
15103                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15104                 .dac_nids = alc269_dac_nids,
15105                 .hp_nid = 0x03,
15106                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15107                 .channel_mode = alc269_modes,
15108                 .unsol_event = alc_sku_unsol_event,
15109                 .setup = alc269vb_laptop_amic_setup,
15110                 .init_hook = alc_inithook,
15111         },
15112         [ALC269VB_DMIC] = {
15113                 .mixers = { alc269vb_laptop_mixer },
15114                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
15115                 .init_verbs = { alc269vb_init_verbs,
15116                                 alc269vb_laptop_dmic_init_verbs },
15117                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15118                 .dac_nids = alc269_dac_nids,
15119                 .hp_nid = 0x03,
15120                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15121                 .channel_mode = alc269_modes,
15122                 .unsol_event = alc_sku_unsol_event,
15123                 .setup = alc269vb_laptop_dmic_setup,
15124                 .init_hook = alc_inithook,
15125         },
15126         [ALC269_FUJITSU] = {
15127                 .mixers = { alc269_fujitsu_mixer },
15128                 .cap_mixer = alc269_laptop_digital_capture_mixer,
15129                 .init_verbs = { alc269_init_verbs,
15130                                 alc269_laptop_dmic_init_verbs },
15131                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15132                 .dac_nids = alc269_dac_nids,
15133                 .hp_nid = 0x03,
15134                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15135                 .channel_mode = alc269_modes,
15136                 .unsol_event = alc_sku_unsol_event,
15137                 .setup = alc269_laptop_dmic_setup,
15138                 .init_hook = alc_inithook,
15139         },
15140         [ALC269_LIFEBOOK] = {
15141                 .mixers = { alc269_lifebook_mixer },
15142                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
15143                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15144                 .dac_nids = alc269_dac_nids,
15145                 .hp_nid = 0x03,
15146                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15147                 .channel_mode = alc269_modes,
15148                 .input_mux = &alc269_capture_source,
15149                 .unsol_event = alc269_lifebook_unsol_event,
15150                 .setup = alc269_lifebook_setup,
15151                 .init_hook = alc269_lifebook_init_hook,
15152         },
15153         [ALC271_ACER] = {
15154                 .mixers = { alc269_asus_mixer },
15155                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
15156                 .init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
15157                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15158                 .dac_nids = alc269_dac_nids,
15159                 .adc_nids = alc262_dmic_adc_nids,
15160                 .num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
15161                 .capsrc_nids = alc262_dmic_capsrc_nids,
15162                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15163                 .channel_mode = alc269_modes,
15164                 .input_mux = &alc269_capture_source,
15165                 .dig_out_nid = ALC880_DIGOUT_NID,
15166                 .unsol_event = alc_sku_unsol_event,
15167                 .setup = alc269vb_laptop_dmic_setup,
15168                 .init_hook = alc_inithook,
15169         },
15170 };
15171
15172 static int alc269_fill_coef(struct hda_codec *codec)
15173 {
15174         int val;
15175
15176         if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
15177                 alc_write_coef_idx(codec, 0xf, 0x960b);
15178                 alc_write_coef_idx(codec, 0xe, 0x8817);
15179         }
15180
15181         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
15182                 alc_write_coef_idx(codec, 0xf, 0x960b);
15183                 alc_write_coef_idx(codec, 0xe, 0x8814);
15184         }
15185
15186         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
15187                 val = alc_read_coef_idx(codec, 0x04);
15188                 /* Power up output pin */
15189                 alc_write_coef_idx(codec, 0x04, val | (1<<11));
15190         }
15191
15192         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
15193                 val = alc_read_coef_idx(codec, 0xd);
15194                 if ((val & 0x0c00) >> 10 != 0x1) {
15195                         /* Capless ramp up clock control */
15196                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
15197                 }
15198                 val = alc_read_coef_idx(codec, 0x17);
15199                 if ((val & 0x01c0) >> 6 != 0x4) {
15200                         /* Class D power on reset */
15201                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
15202                 }
15203         }
15204
15205         val = alc_read_coef_idx(codec, 0xd); /* Class D */
15206         alc_write_coef_idx(codec, 0xd, val | (1<<14));
15207
15208         val = alc_read_coef_idx(codec, 0x4); /* HP */
15209         alc_write_coef_idx(codec, 0x4, val | (1<<11));
15210
15211         return 0;
15212 }
15213
15214 static int patch_alc269(struct hda_codec *codec)
15215 {
15216         struct alc_spec *spec;
15217         int board_config, coef;
15218         int err;
15219
15220         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15221         if (spec == NULL)
15222                 return -ENOMEM;
15223
15224         codec->spec = spec;
15225
15226         alc_auto_parse_customize_define(codec);
15227
15228         if (codec->vendor_id == 0x10ec0269) {
15229                 coef = alc_read_coef_idx(codec, 0);
15230                 if ((coef & 0x00f0) == 0x0010) {
15231                         if (codec->bus->pci->subsystem_vendor == 0x1025 &&
15232                             spec->cdefine.platform_type == 1) {
15233                                 alc_codec_rename(codec, "ALC271X");
15234                                 spec->codec_variant = ALC269_TYPE_ALC271X;
15235                         } else if ((coef & 0xf000) == 0x1000) {
15236                                 spec->codec_variant = ALC269_TYPE_ALC270;
15237                         } else if ((coef & 0xf000) == 0x2000) {
15238                                 alc_codec_rename(codec, "ALC259");
15239                                 spec->codec_variant = ALC269_TYPE_ALC259;
15240                         } else if ((coef & 0xf000) == 0x3000) {
15241                                 alc_codec_rename(codec, "ALC258");
15242                                 spec->codec_variant = ALC269_TYPE_ALC258;
15243                         } else {
15244                                 alc_codec_rename(codec, "ALC269VB");
15245                                 spec->codec_variant = ALC269_TYPE_ALC269VB;
15246                         }
15247                 } else
15248                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
15249                 alc269_fill_coef(codec);
15250         }
15251
15252         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
15253                                                   alc269_models,
15254                                                   alc269_cfg_tbl);
15255
15256         if (board_config < 0) {
15257                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15258                        codec->chip_name);
15259                 board_config = ALC269_AUTO;
15260         }
15261
15262         if (board_config == ALC269_AUTO) {
15263                 alc_pick_fixup(codec, NULL, alc269_fixup_tbl, alc269_fixups);
15264                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
15265         }
15266
15267         if (board_config == ALC269_AUTO) {
15268                 /* automatic parse from the BIOS config */
15269                 err = alc269_parse_auto_config(codec);
15270                 if (err < 0) {
15271                         alc_free(codec);
15272                         return err;
15273                 } else if (!err) {
15274                         printk(KERN_INFO
15275                                "hda_codec: Cannot set up configuration "
15276                                "from BIOS.  Using base mode...\n");
15277                         board_config = ALC269_BASIC;
15278                 }
15279         }
15280
15281         if (has_cdefine_beep(codec)) {
15282                 err = snd_hda_attach_beep_device(codec, 0x1);
15283                 if (err < 0) {
15284                         alc_free(codec);
15285                         return err;
15286                 }
15287         }
15288
15289         if (board_config != ALC269_AUTO)
15290                 setup_preset(codec, &alc269_presets[board_config]);
15291
15292         if (board_config == ALC269_QUANTA_FL1) {
15293                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
15294                  * fix the sample rate of analog I/O to 44.1kHz
15295                  */
15296                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
15297                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
15298         } else if (spec->dual_adc_switch) {
15299                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15300                 /* switch ADC dynamically */
15301                 spec->stream_analog_capture = &dualmic_pcm_analog_capture;
15302         } else {
15303                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15304                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
15305         }
15306         spec->stream_digital_playback = &alc269_pcm_digital_playback;
15307         spec->stream_digital_capture = &alc269_pcm_digital_capture;
15308
15309         if (!spec->adc_nids) { /* wasn't filled automatically? use default */
15310                 if (spec->codec_variant == ALC269_TYPE_NORMAL) {
15311                         spec->adc_nids = alc269_adc_nids;
15312                         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
15313                         spec->capsrc_nids = alc269_capsrc_nids;
15314                 } else {
15315                         spec->adc_nids = alc269vb_adc_nids;
15316                         spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
15317                         spec->capsrc_nids = alc269vb_capsrc_nids;
15318                 }
15319         }
15320
15321         if (!spec->cap_mixer)
15322                 set_capture_mixer(codec);
15323         if (has_cdefine_beep(codec))
15324                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
15325
15326         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
15327
15328         spec->vmaster_nid = 0x02;
15329
15330         codec->patch_ops = alc_patch_ops;
15331 #ifdef SND_HDA_NEEDS_RESUME
15332         codec->patch_ops.resume = alc269_resume;
15333 #endif
15334         if (board_config == ALC269_AUTO)
15335                 spec->init_hook = alc269_auto_init;
15336         spec->shutup = alc269_shutup;
15337
15338         alc_init_jacks(codec);
15339 #ifdef CONFIG_SND_HDA_POWER_SAVE
15340         if (!spec->loopback.amplist)
15341                 spec->loopback.amplist = alc269_loopbacks;
15342         if (alc269_mic2_for_mute_led(codec))
15343                 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
15344 #endif
15345
15346         return 0;
15347 }
15348
15349 /*
15350  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
15351  */
15352
15353 /*
15354  * set the path ways for 2 channel output
15355  * need to set the codec line out and mic 1 pin widgets to inputs
15356  */
15357 static const struct hda_verb alc861_threestack_ch2_init[] = {
15358         /* set pin widget 1Ah (line in) for input */
15359         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15360         /* set pin widget 18h (mic1/2) for input, for mic also enable
15361          * the vref
15362          */
15363         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15364
15365         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15366 #if 0
15367         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15368         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15369 #endif
15370         { } /* end */
15371 };
15372 /*
15373  * 6ch mode
15374  * need to set the codec line out and mic 1 pin widgets to outputs
15375  */
15376 static const struct hda_verb alc861_threestack_ch6_init[] = {
15377         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15378         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15379         /* set pin widget 18h (mic1) for output (CLFE)*/
15380         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15381
15382         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15383         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15384
15385         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15386 #if 0
15387         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15388         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15389 #endif
15390         { } /* end */
15391 };
15392
15393 static const struct hda_channel_mode alc861_threestack_modes[2] = {
15394         { 2, alc861_threestack_ch2_init },
15395         { 6, alc861_threestack_ch6_init },
15396 };
15397 /* Set mic1 as input and unmute the mixer */
15398 static const struct hda_verb alc861_uniwill_m31_ch2_init[] = {
15399         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15400         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15401         { } /* end */
15402 };
15403 /* Set mic1 as output and mute mixer */
15404 static const struct hda_verb alc861_uniwill_m31_ch4_init[] = {
15405         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15406         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15407         { } /* end */
15408 };
15409
15410 static const struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
15411         { 2, alc861_uniwill_m31_ch2_init },
15412         { 4, alc861_uniwill_m31_ch4_init },
15413 };
15414
15415 /* Set mic1 and line-in as input and unmute the mixer */
15416 static const struct hda_verb alc861_asus_ch2_init[] = {
15417         /* set pin widget 1Ah (line in) for input */
15418         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15419         /* set pin widget 18h (mic1/2) for input, for mic also enable
15420          * the vref
15421          */
15422         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15423
15424         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15425 #if 0
15426         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15427         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15428 #endif
15429         { } /* end */
15430 };
15431 /* Set mic1 nad line-in as output and mute mixer */
15432 static const struct hda_verb alc861_asus_ch6_init[] = {
15433         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15434         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15435         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15436         /* set pin widget 18h (mic1) for output (CLFE)*/
15437         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15438         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15439         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15440         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15441
15442         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15443 #if 0
15444         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15445         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15446 #endif
15447         { } /* end */
15448 };
15449
15450 static const struct hda_channel_mode alc861_asus_modes[2] = {
15451         { 2, alc861_asus_ch2_init },
15452         { 6, alc861_asus_ch6_init },
15453 };
15454
15455 /* patch-ALC861 */
15456
15457 static const struct snd_kcontrol_new alc861_base_mixer[] = {
15458         /* output mixer control */
15459         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15460         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15461         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15462         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15463         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15464
15465         /*Input mixer control */
15466         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15467            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15468         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15469         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15470         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15471         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15472         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15473         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15474         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15475         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15476
15477         { } /* end */
15478 };
15479
15480 static const struct snd_kcontrol_new alc861_3ST_mixer[] = {
15481         /* output mixer control */
15482         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15483         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15484         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15485         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15486         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15487
15488         /* Input mixer control */
15489         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15490            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15491         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15492         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15493         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15494         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15495         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15496         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15497         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15498         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15499
15500         {
15501                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15502                 .name = "Channel Mode",
15503                 .info = alc_ch_mode_info,
15504                 .get = alc_ch_mode_get,
15505                 .put = alc_ch_mode_put,
15506                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
15507         },
15508         { } /* end */
15509 };
15510
15511 static const struct snd_kcontrol_new alc861_toshiba_mixer[] = {
15512         /* output mixer control */
15513         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15514         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15515         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15516
15517         { } /* end */
15518 };
15519
15520 static const struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
15521         /* output mixer control */
15522         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15523         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15524         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15525         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15526         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15527
15528         /* Input mixer control */
15529         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15530            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15531         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15532         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15533         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15534         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15535         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15536         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15537         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15538         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15539
15540         {
15541                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15542                 .name = "Channel Mode",
15543                 .info = alc_ch_mode_info,
15544                 .get = alc_ch_mode_get,
15545                 .put = alc_ch_mode_put,
15546                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
15547         },
15548         { } /* end */
15549 };
15550
15551 static const struct snd_kcontrol_new alc861_asus_mixer[] = {
15552         /* output mixer control */
15553         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15554         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15555         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15556         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15557         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15558
15559         /* Input mixer control */
15560         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15561         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15562         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15563         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15564         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15565         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15566         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15567         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15568         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15569         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
15570
15571         {
15572                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15573                 .name = "Channel Mode",
15574                 .info = alc_ch_mode_info,
15575                 .get = alc_ch_mode_get,
15576                 .put = alc_ch_mode_put,
15577                 .private_value = ARRAY_SIZE(alc861_asus_modes),
15578         },
15579         { }
15580 };
15581
15582 /* additional mixer */
15583 static const struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
15584         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15585         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15586         { }
15587 };
15588
15589 /*
15590  * generic initialization of ADC, input mixers and output mixers
15591  */
15592 static const struct hda_verb alc861_base_init_verbs[] = {
15593         /*
15594          * Unmute ADC0 and set the default input to mic-in
15595          */
15596         /* port-A for surround (rear panel) */
15597         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15598         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
15599         /* port-B for mic-in (rear panel) with vref */
15600         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15601         /* port-C for line-in (rear panel) */
15602         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15603         /* port-D for Front */
15604         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15605         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15606         /* port-E for HP out (front panel) */
15607         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15608         /* route front PCM to HP */
15609         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15610         /* port-F for mic-in (front panel) with vref */
15611         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15612         /* port-G for CLFE (rear panel) */
15613         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15614         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15615         /* port-H for side (rear panel) */
15616         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15617         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
15618         /* CD-in */
15619         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15620         /* route front mic to ADC1*/
15621         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15622         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15623
15624         /* Unmute DAC0~3 & spdif out*/
15625         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15626         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15627         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15628         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15629         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15630
15631         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15632         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15633         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15634         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15635         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15636
15637         /* Unmute Stereo Mixer 15 */
15638         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15639         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15640         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15641         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15642
15643         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15644         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15645         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15646         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15647         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15648         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15649         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15650         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15651         /* hp used DAC 3 (Front) */
15652         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15653         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15654
15655         { }
15656 };
15657
15658 static const struct hda_verb alc861_threestack_init_verbs[] = {
15659         /*
15660          * Unmute ADC0 and set the default input to mic-in
15661          */
15662         /* port-A for surround (rear panel) */
15663         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15664         /* port-B for mic-in (rear panel) with vref */
15665         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15666         /* port-C for line-in (rear panel) */
15667         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15668         /* port-D for Front */
15669         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15670         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15671         /* port-E for HP out (front panel) */
15672         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15673         /* route front PCM to HP */
15674         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15675         /* port-F for mic-in (front panel) with vref */
15676         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15677         /* port-G for CLFE (rear panel) */
15678         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15679         /* port-H for side (rear panel) */
15680         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15681         /* CD-in */
15682         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15683         /* route front mic to ADC1*/
15684         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15685         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15686         /* Unmute DAC0~3 & spdif out*/
15687         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15688         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15689         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15690         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15691         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15692
15693         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15694         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15695         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15696         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15697         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15698
15699         /* Unmute Stereo Mixer 15 */
15700         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15701         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15702         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15703         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15704
15705         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15706         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15707         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15708         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15709         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15710         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15711         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15712         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15713         /* hp used DAC 3 (Front) */
15714         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15715         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15716         { }
15717 };
15718
15719 static const struct hda_verb alc861_uniwill_m31_init_verbs[] = {
15720         /*
15721          * Unmute ADC0 and set the default input to mic-in
15722          */
15723         /* port-A for surround (rear panel) */
15724         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15725         /* port-B for mic-in (rear panel) with vref */
15726         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15727         /* port-C for line-in (rear panel) */
15728         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15729         /* port-D for Front */
15730         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15731         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15732         /* port-E for HP out (front panel) */
15733         /* this has to be set to VREF80 */
15734         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15735         /* route front PCM to HP */
15736         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15737         /* port-F for mic-in (front panel) with vref */
15738         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15739         /* port-G for CLFE (rear panel) */
15740         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15741         /* port-H for side (rear panel) */
15742         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15743         /* CD-in */
15744         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15745         /* route front mic to ADC1*/
15746         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15747         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15748         /* Unmute DAC0~3 & spdif out*/
15749         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15750         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15751         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15752         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15753         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15754
15755         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15756         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15757         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15758         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15759         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15760
15761         /* Unmute Stereo Mixer 15 */
15762         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15763         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15764         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15765         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15766
15767         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15768         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15769         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15770         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15771         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15772         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15773         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15774         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15775         /* hp used DAC 3 (Front) */
15776         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15777         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15778         { }
15779 };
15780
15781 static const struct hda_verb alc861_asus_init_verbs[] = {
15782         /*
15783          * Unmute ADC0 and set the default input to mic-in
15784          */
15785         /* port-A for surround (rear panel)
15786          * according to codec#0 this is the HP jack
15787          */
15788         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
15789         /* route front PCM to HP */
15790         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
15791         /* port-B for mic-in (rear panel) with vref */
15792         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15793         /* port-C for line-in (rear panel) */
15794         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15795         /* port-D for Front */
15796         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15797         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15798         /* port-E for HP out (front panel) */
15799         /* this has to be set to VREF80 */
15800         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15801         /* route front PCM to HP */
15802         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15803         /* port-F for mic-in (front panel) with vref */
15804         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15805         /* port-G for CLFE (rear panel) */
15806         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15807         /* port-H for side (rear panel) */
15808         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15809         /* CD-in */
15810         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15811         /* route front mic to ADC1*/
15812         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15813         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15814         /* Unmute DAC0~3 & spdif out*/
15815         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15816         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15817         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15818         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15819         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15820         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15821         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15822         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15823         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15824         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15825
15826         /* Unmute Stereo Mixer 15 */
15827         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15828         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15829         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15830         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15831
15832         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15833         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15834         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15835         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15836         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15837         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15838         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15839         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15840         /* hp used DAC 3 (Front) */
15841         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15842         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15843         { }
15844 };
15845
15846 /* additional init verbs for ASUS laptops */
15847 static const struct hda_verb alc861_asus_laptop_init_verbs[] = {
15848         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
15849         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
15850         { }
15851 };
15852
15853 /*
15854  * generic initialization of ADC, input mixers and output mixers
15855  */
15856 static const struct hda_verb alc861_auto_init_verbs[] = {
15857         /*
15858          * Unmute ADC0 and set the default input to mic-in
15859          */
15860         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
15861         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15862
15863         /* Unmute DAC0~3 & spdif out*/
15864         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15865         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15866         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15867         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15868         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15869
15870         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15871         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15872         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15873         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15874         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15875
15876         /* Unmute Stereo Mixer 15 */
15877         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15878         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15879         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15880         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
15881
15882         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15883         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15884         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15885         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15886         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15887         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15888         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15889         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15890
15891         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15892         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15893         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15894         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15895         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15896         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15897         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15898         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15899
15900         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
15901
15902         { }
15903 };
15904
15905 static const struct hda_verb alc861_toshiba_init_verbs[] = {
15906         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15907
15908         { }
15909 };
15910
15911 /* toggle speaker-output according to the hp-jack state */
15912 static void alc861_toshiba_automute(struct hda_codec *codec)
15913 {
15914         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
15915
15916         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
15917                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
15918         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
15919                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
15920 }
15921
15922 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
15923                                        unsigned int res)
15924 {
15925         if ((res >> 26) == ALC880_HP_EVENT)
15926                 alc861_toshiba_automute(codec);
15927 }
15928
15929 /* pcm configuration: identical with ALC880 */
15930 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
15931 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
15932 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
15933 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
15934
15935
15936 #define ALC861_DIGOUT_NID       0x07
15937
15938 static const struct hda_channel_mode alc861_8ch_modes[1] = {
15939         { 8, NULL }
15940 };
15941
15942 static const hda_nid_t alc861_dac_nids[4] = {
15943         /* front, surround, clfe, side */
15944         0x03, 0x06, 0x05, 0x04
15945 };
15946
15947 static const hda_nid_t alc660_dac_nids[3] = {
15948         /* front, clfe, surround */
15949         0x03, 0x05, 0x06
15950 };
15951
15952 static const hda_nid_t alc861_adc_nids[1] = {
15953         /* ADC0-2 */
15954         0x08,
15955 };
15956
15957 static const struct hda_input_mux alc861_capture_source = {
15958         .num_items = 5,
15959         .items = {
15960                 { "Mic", 0x0 },
15961                 { "Front Mic", 0x3 },
15962                 { "Line", 0x1 },
15963                 { "CD", 0x4 },
15964                 { "Mixer", 0x5 },
15965         },
15966 };
15967
15968 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
15969 {
15970         struct alc_spec *spec = codec->spec;
15971         hda_nid_t mix, srcs[5];
15972         int i, j, num;
15973
15974         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
15975                 return 0;
15976         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15977         if (num < 0)
15978                 return 0;
15979         for (i = 0; i < num; i++) {
15980                 unsigned int type;
15981                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
15982                 if (type != AC_WID_AUD_OUT)
15983                         continue;
15984                 for (j = 0; j < spec->multiout.num_dacs; j++)
15985                         if (spec->multiout.dac_nids[j] == srcs[i])
15986                                 break;
15987                 if (j >= spec->multiout.num_dacs)
15988                         return srcs[i];
15989         }
15990         return 0;
15991 }
15992
15993 /* fill in the dac_nids table from the parsed pin configuration */
15994 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
15995                                      const struct auto_pin_cfg *cfg)
15996 {
15997         struct alc_spec *spec = codec->spec;
15998         int i;
15999         hda_nid_t nid, dac;
16000
16001         spec->multiout.dac_nids = spec->private_dac_nids;
16002         for (i = 0; i < cfg->line_outs; i++) {
16003                 nid = cfg->line_out_pins[i];
16004                 dac = alc861_look_for_dac(codec, nid);
16005                 if (!dac)
16006                         continue;
16007                 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
16008         }
16009         return 0;
16010 }
16011
16012 static int __alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
16013                                   hda_nid_t nid, int idx, unsigned int chs)
16014 {
16015         return __add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
16016                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
16017 }
16018
16019 #define alc861_create_out_sw(codec, pfx, nid, chs) \
16020         __alc861_create_out_sw(codec, pfx, nid, 0, chs)
16021
16022 /* add playback controls from the parsed DAC table */
16023 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
16024                                              const struct auto_pin_cfg *cfg)
16025 {
16026         struct alc_spec *spec = codec->spec;
16027         static const char * const chname[4] = {
16028                 "Front", "Surround", NULL /*CLFE*/, "Side"
16029         };
16030         const char *pfx = alc_get_line_out_pfx(spec, true);
16031         hda_nid_t nid;
16032         int i, err, noutputs;
16033
16034         noutputs = cfg->line_outs;
16035         if (spec->multi_ios > 0)
16036                 noutputs += spec->multi_ios;
16037
16038         for (i = 0; i < noutputs; i++) {
16039                 nid = spec->multiout.dac_nids[i];
16040                 if (!nid)
16041                         continue;
16042                 if (!pfx && i == 2) {
16043                         /* Center/LFE */
16044                         err = alc861_create_out_sw(codec, "Center", nid, 1);
16045                         if (err < 0)
16046                                 return err;
16047                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
16048                         if (err < 0)
16049                                 return err;
16050                 } else {
16051                         const char *name = pfx;
16052                         int index = i;
16053                         if (!name) {
16054                                 name = chname[i];
16055                                 index = 0;
16056                         }
16057                         err = __alc861_create_out_sw(codec, name, nid, index, 3);
16058                         if (err < 0)
16059                                 return err;
16060                 }
16061         }
16062         return 0;
16063 }
16064
16065 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
16066 {
16067         struct alc_spec *spec = codec->spec;
16068         int err;
16069         hda_nid_t nid;
16070
16071         if (!pin)
16072                 return 0;
16073
16074         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
16075                 nid = alc861_look_for_dac(codec, pin);
16076                 if (nid) {
16077                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
16078                         if (err < 0)
16079                                 return err;
16080                         spec->multiout.hp_nid = nid;
16081                 }
16082         }
16083         return 0;
16084 }
16085
16086 /* create playback/capture controls for input pins */
16087 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
16088                                                 const struct auto_pin_cfg *cfg)
16089 {
16090         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
16091 }
16092
16093 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
16094                                               hda_nid_t nid,
16095                                               int pin_type, hda_nid_t dac)
16096 {
16097         hda_nid_t mix, srcs[5];
16098         int i, num;
16099
16100         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
16101                             pin_type);
16102         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16103                             AMP_OUT_UNMUTE);
16104         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
16105                 return;
16106         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
16107         if (num < 0)
16108                 return;
16109         for (i = 0; i < num; i++) {
16110                 unsigned int mute;
16111                 if (srcs[i] == dac || srcs[i] == 0x15)
16112                         mute = AMP_IN_UNMUTE(i);
16113                 else
16114                         mute = AMP_IN_MUTE(i);
16115                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16116                                     mute);
16117         }
16118 }
16119
16120 static void alc861_auto_init_multi_out(struct hda_codec *codec)
16121 {
16122         struct alc_spec *spec = codec->spec;
16123         int i;
16124
16125         for (i = 0; i < spec->autocfg.line_outs; i++) {
16126                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16127                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16128                 if (nid)
16129                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
16130                                                           spec->multiout.dac_nids[i]);
16131         }
16132 }
16133
16134 static void alc861_auto_init_hp_out(struct hda_codec *codec)
16135 {
16136         struct alc_spec *spec = codec->spec;
16137
16138         if (spec->autocfg.hp_outs)
16139                 alc861_auto_set_output_and_unmute(codec,
16140                                                   spec->autocfg.hp_pins[0],
16141                                                   PIN_HP,
16142                                                   spec->multiout.hp_nid);
16143         if (spec->autocfg.speaker_outs)
16144                 alc861_auto_set_output_and_unmute(codec,
16145                                                   spec->autocfg.speaker_pins[0],
16146                                                   PIN_OUT,
16147                                                   spec->multiout.dac_nids[0]);
16148 }
16149
16150 static void alc861_auto_init_analog_input(struct hda_codec *codec)
16151 {
16152         struct alc_spec *spec = codec->spec;
16153         struct auto_pin_cfg *cfg = &spec->autocfg;
16154         int i;
16155
16156         for (i = 0; i < cfg->num_inputs; i++) {
16157                 hda_nid_t nid = cfg->inputs[i].pin;
16158                 if (nid >= 0x0c && nid <= 0x11)
16159                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
16160         }
16161 }
16162
16163 /* parse the BIOS configuration and set up the alc_spec */
16164 /* return 1 if successful, 0 if the proper config is not found,
16165  * or a negative error code
16166  */
16167 static int alc861_parse_auto_config(struct hda_codec *codec)
16168 {
16169         struct alc_spec *spec = codec->spec;
16170         int err;
16171         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
16172
16173         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16174                                            alc861_ignore);
16175         if (err < 0)
16176                 return err;
16177         if (!spec->autocfg.line_outs)
16178                 return 0; /* can't find valid BIOS pin config */
16179
16180         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
16181         if (err < 0)
16182                 return err;
16183         err = alc_auto_add_multi_channel_mode(codec);
16184         if (err < 0)
16185                 return err;
16186         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
16187         if (err < 0)
16188                 return err;
16189         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
16190         if (err < 0)
16191                 return err;
16192         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
16193         if (err < 0)
16194                 return err;
16195
16196         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16197
16198         alc_auto_parse_digital(codec);
16199
16200         if (spec->kctls.list)
16201                 add_mixer(spec, spec->kctls.list);
16202
16203         add_verb(spec, alc861_auto_init_verbs);
16204
16205         spec->num_mux_defs = 1;
16206         spec->input_mux = &spec->private_imux[0];
16207
16208         spec->adc_nids = alc861_adc_nids;
16209         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
16210         set_capture_mixer(codec);
16211
16212         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
16213
16214         return 1;
16215 }
16216
16217 /* additional initialization for auto-configuration model */
16218 static void alc861_auto_init(struct hda_codec *codec)
16219 {
16220         struct alc_spec *spec = codec->spec;
16221         alc861_auto_init_multi_out(codec);
16222         alc861_auto_init_hp_out(codec);
16223         alc861_auto_init_analog_input(codec);
16224         alc_auto_init_digital(codec);
16225         if (spec->unsol_event)
16226                 alc_inithook(codec);
16227 }
16228
16229 #ifdef CONFIG_SND_HDA_POWER_SAVE
16230 static const struct hda_amp_list alc861_loopbacks[] = {
16231         { 0x15, HDA_INPUT, 0 },
16232         { 0x15, HDA_INPUT, 1 },
16233         { 0x15, HDA_INPUT, 2 },
16234         { 0x15, HDA_INPUT, 3 },
16235         { } /* end */
16236 };
16237 #endif
16238
16239
16240 /*
16241  * configuration and preset
16242  */
16243 static const char * const alc861_models[ALC861_MODEL_LAST] = {
16244         [ALC861_3ST]            = "3stack",
16245         [ALC660_3ST]            = "3stack-660",
16246         [ALC861_3ST_DIG]        = "3stack-dig",
16247         [ALC861_6ST_DIG]        = "6stack-dig",
16248         [ALC861_UNIWILL_M31]    = "uniwill-m31",
16249         [ALC861_TOSHIBA]        = "toshiba",
16250         [ALC861_ASUS]           = "asus",
16251         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
16252         [ALC861_AUTO]           = "auto",
16253 };
16254
16255 static const struct snd_pci_quirk alc861_cfg_tbl[] = {
16256         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
16257         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16258         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16259         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
16260         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
16261         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
16262         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
16263         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
16264          *        Any other models that need this preset?
16265          */
16266         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
16267         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
16268         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
16269         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
16270         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
16271         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
16272         /* FIXME: the below seems conflict */
16273         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
16274         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
16275         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
16276         {}
16277 };
16278
16279 static const struct alc_config_preset alc861_presets[] = {
16280         [ALC861_3ST] = {
16281                 .mixers = { alc861_3ST_mixer },
16282                 .init_verbs = { alc861_threestack_init_verbs },
16283                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16284                 .dac_nids = alc861_dac_nids,
16285                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16286                 .channel_mode = alc861_threestack_modes,
16287                 .need_dac_fix = 1,
16288                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16289                 .adc_nids = alc861_adc_nids,
16290                 .input_mux = &alc861_capture_source,
16291         },
16292         [ALC861_3ST_DIG] = {
16293                 .mixers = { alc861_base_mixer },
16294                 .init_verbs = { alc861_threestack_init_verbs },
16295                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16296                 .dac_nids = alc861_dac_nids,
16297                 .dig_out_nid = ALC861_DIGOUT_NID,
16298                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16299                 .channel_mode = alc861_threestack_modes,
16300                 .need_dac_fix = 1,
16301                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16302                 .adc_nids = alc861_adc_nids,
16303                 .input_mux = &alc861_capture_source,
16304         },
16305         [ALC861_6ST_DIG] = {
16306                 .mixers = { alc861_base_mixer },
16307                 .init_verbs = { alc861_base_init_verbs },
16308                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16309                 .dac_nids = alc861_dac_nids,
16310                 .dig_out_nid = ALC861_DIGOUT_NID,
16311                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
16312                 .channel_mode = alc861_8ch_modes,
16313                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16314                 .adc_nids = alc861_adc_nids,
16315                 .input_mux = &alc861_capture_source,
16316         },
16317         [ALC660_3ST] = {
16318                 .mixers = { alc861_3ST_mixer },
16319                 .init_verbs = { alc861_threestack_init_verbs },
16320                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
16321                 .dac_nids = alc660_dac_nids,
16322                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16323                 .channel_mode = alc861_threestack_modes,
16324                 .need_dac_fix = 1,
16325                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16326                 .adc_nids = alc861_adc_nids,
16327                 .input_mux = &alc861_capture_source,
16328         },
16329         [ALC861_UNIWILL_M31] = {
16330                 .mixers = { alc861_uniwill_m31_mixer },
16331                 .init_verbs = { alc861_uniwill_m31_init_verbs },
16332                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16333                 .dac_nids = alc861_dac_nids,
16334                 .dig_out_nid = ALC861_DIGOUT_NID,
16335                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
16336                 .channel_mode = alc861_uniwill_m31_modes,
16337                 .need_dac_fix = 1,
16338                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16339                 .adc_nids = alc861_adc_nids,
16340                 .input_mux = &alc861_capture_source,
16341         },
16342         [ALC861_TOSHIBA] = {
16343                 .mixers = { alc861_toshiba_mixer },
16344                 .init_verbs = { alc861_base_init_verbs,
16345                                 alc861_toshiba_init_verbs },
16346                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16347                 .dac_nids = alc861_dac_nids,
16348                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16349                 .channel_mode = alc883_3ST_2ch_modes,
16350                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16351                 .adc_nids = alc861_adc_nids,
16352                 .input_mux = &alc861_capture_source,
16353                 .unsol_event = alc861_toshiba_unsol_event,
16354                 .init_hook = alc861_toshiba_automute,
16355         },
16356         [ALC861_ASUS] = {
16357                 .mixers = { alc861_asus_mixer },
16358                 .init_verbs = { alc861_asus_init_verbs },
16359                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16360                 .dac_nids = alc861_dac_nids,
16361                 .dig_out_nid = ALC861_DIGOUT_NID,
16362                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
16363                 .channel_mode = alc861_asus_modes,
16364                 .need_dac_fix = 1,
16365                 .hp_nid = 0x06,
16366                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16367                 .adc_nids = alc861_adc_nids,
16368                 .input_mux = &alc861_capture_source,
16369         },
16370         [ALC861_ASUS_LAPTOP] = {
16371                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
16372                 .init_verbs = { alc861_asus_init_verbs,
16373                                 alc861_asus_laptop_init_verbs },
16374                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16375                 .dac_nids = alc861_dac_nids,
16376                 .dig_out_nid = ALC861_DIGOUT_NID,
16377                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16378                 .channel_mode = alc883_3ST_2ch_modes,
16379                 .need_dac_fix = 1,
16380                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16381                 .adc_nids = alc861_adc_nids,
16382                 .input_mux = &alc861_capture_source,
16383         },
16384 };
16385
16386 /* Pin config fixes */
16387 enum {
16388         PINFIX_FSC_AMILO_PI1505,
16389 };
16390
16391 static const struct alc_fixup alc861_fixups[] = {
16392         [PINFIX_FSC_AMILO_PI1505] = {
16393                 .type = ALC_FIXUP_PINS,
16394                 .v.pins = (const struct alc_pincfg[]) {
16395                         { 0x0b, 0x0221101f }, /* HP */
16396                         { 0x0f, 0x90170310 }, /* speaker */
16397                         { }
16398                 }
16399         },
16400 };
16401
16402 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
16403         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
16404         {}
16405 };
16406
16407 static int patch_alc861(struct hda_codec *codec)
16408 {
16409         struct alc_spec *spec;
16410         int board_config;
16411         int err;
16412
16413         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16414         if (spec == NULL)
16415                 return -ENOMEM;
16416
16417         codec->spec = spec;
16418
16419         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
16420                                                   alc861_models,
16421                                                   alc861_cfg_tbl);
16422
16423         if (board_config < 0) {
16424                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16425                        codec->chip_name);
16426                 board_config = ALC861_AUTO;
16427         }
16428
16429         if (board_config == ALC861_AUTO) {
16430                 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
16431                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
16432         }
16433
16434         if (board_config == ALC861_AUTO) {
16435                 /* automatic parse from the BIOS config */
16436                 err = alc861_parse_auto_config(codec);
16437                 if (err < 0) {
16438                         alc_free(codec);
16439                         return err;
16440                 } else if (!err) {
16441                         printk(KERN_INFO
16442                                "hda_codec: Cannot set up configuration "
16443                                "from BIOS.  Using base mode...\n");
16444                    board_config = ALC861_3ST_DIG;
16445                 }
16446         }
16447
16448         err = snd_hda_attach_beep_device(codec, 0x23);
16449         if (err < 0) {
16450                 alc_free(codec);
16451                 return err;
16452         }
16453
16454         if (board_config != ALC861_AUTO)
16455                 setup_preset(codec, &alc861_presets[board_config]);
16456
16457         spec->stream_analog_playback = &alc861_pcm_analog_playback;
16458         spec->stream_analog_capture = &alc861_pcm_analog_capture;
16459
16460         spec->stream_digital_playback = &alc861_pcm_digital_playback;
16461         spec->stream_digital_capture = &alc861_pcm_digital_capture;
16462
16463         if (!spec->cap_mixer)
16464                 set_capture_mixer(codec);
16465         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
16466
16467         spec->vmaster_nid = 0x03;
16468
16469         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
16470
16471         codec->patch_ops = alc_patch_ops;
16472         if (board_config == ALC861_AUTO) {
16473                 spec->init_hook = alc861_auto_init;
16474 #ifdef CONFIG_SND_HDA_POWER_SAVE
16475                 spec->power_hook = alc_power_eapd;
16476 #endif
16477         }
16478 #ifdef CONFIG_SND_HDA_POWER_SAVE
16479         if (!spec->loopback.amplist)
16480                 spec->loopback.amplist = alc861_loopbacks;
16481 #endif
16482
16483         return 0;
16484 }
16485
16486 /*
16487  * ALC861-VD support
16488  *
16489  * Based on ALC882
16490  *
16491  * In addition, an independent DAC
16492  */
16493 #define ALC861VD_DIGOUT_NID     0x06
16494
16495 static const hda_nid_t alc861vd_dac_nids[4] = {
16496         /* front, surr, clfe, side surr */
16497         0x02, 0x03, 0x04, 0x05
16498 };
16499
16500 /* dac_nids for ALC660vd are in a different order - according to
16501  * Realtek's driver.
16502  * This should probably result in a different mixer for 6stack models
16503  * of ALC660vd codecs, but for now there is only 3stack mixer
16504  * - and it is the same as in 861vd.
16505  * adc_nids in ALC660vd are (is) the same as in 861vd
16506  */
16507 static const hda_nid_t alc660vd_dac_nids[3] = {
16508         /* front, rear, clfe, rear_surr */
16509         0x02, 0x04, 0x03
16510 };
16511
16512 static const hda_nid_t alc861vd_adc_nids[1] = {
16513         /* ADC0 */
16514         0x09,
16515 };
16516
16517 static const hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
16518
16519 /* input MUX */
16520 /* FIXME: should be a matrix-type input source selection */
16521 static const struct hda_input_mux alc861vd_capture_source = {
16522         .num_items = 4,
16523         .items = {
16524                 { "Mic", 0x0 },
16525                 { "Front Mic", 0x1 },
16526                 { "Line", 0x2 },
16527                 { "CD", 0x4 },
16528         },
16529 };
16530
16531 static const struct hda_input_mux alc861vd_dallas_capture_source = {
16532         .num_items = 2,
16533         .items = {
16534                 { "Mic", 0x0 },
16535                 { "Internal Mic", 0x1 },
16536         },
16537 };
16538
16539 static const struct hda_input_mux alc861vd_hp_capture_source = {
16540         .num_items = 2,
16541         .items = {
16542                 { "Front Mic", 0x0 },
16543                 { "ATAPI Mic", 0x1 },
16544         },
16545 };
16546
16547 /*
16548  * 2ch mode
16549  */
16550 static const struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
16551         { 2, NULL }
16552 };
16553
16554 /*
16555  * 6ch mode
16556  */
16557 static const struct hda_verb alc861vd_6stack_ch6_init[] = {
16558         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16559         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16560         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16561         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16562         { } /* end */
16563 };
16564
16565 /*
16566  * 8ch mode
16567  */
16568 static const struct hda_verb alc861vd_6stack_ch8_init[] = {
16569         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16570         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16571         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16572         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16573         { } /* end */
16574 };
16575
16576 static const struct hda_channel_mode alc861vd_6stack_modes[2] = {
16577         { 6, alc861vd_6stack_ch6_init },
16578         { 8, alc861vd_6stack_ch8_init },
16579 };
16580
16581 static const struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
16582         {
16583                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16584                 .name = "Channel Mode",
16585                 .info = alc_ch_mode_info,
16586                 .get = alc_ch_mode_get,
16587                 .put = alc_ch_mode_put,
16588         },
16589         { } /* end */
16590 };
16591
16592 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16593  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16594  */
16595 static const struct snd_kcontrol_new alc861vd_6st_mixer[] = {
16596         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16597         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16598
16599         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16600         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
16601
16602         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
16603                                 HDA_OUTPUT),
16604         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
16605                                 HDA_OUTPUT),
16606         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
16607         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
16608
16609         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
16610         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
16611
16612         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16613
16614         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16615         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16616         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16617
16618         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16619         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16620         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16621
16622         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16623         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16624
16625         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16626         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16627
16628         { } /* end */
16629 };
16630
16631 static const struct snd_kcontrol_new alc861vd_3st_mixer[] = {
16632         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16633         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16634
16635         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16636
16637         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16638         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16639         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16640
16641         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16642         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16643         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16644
16645         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16646         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16647
16648         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16649         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16650
16651         { } /* end */
16652 };
16653
16654 static const struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
16655         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16656         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
16657         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16658
16659         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16660
16661         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16662         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16663         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16664
16665         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16666         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16667         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16668
16669         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16670         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16671
16672         { } /* end */
16673 };
16674
16675 /* Pin assignment: Speaker=0x14, HP = 0x15,
16676  *                 Mic=0x18, Internal Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
16677  */
16678 static const struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
16679         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16680         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
16681         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16682         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16683         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16684         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16685         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16686         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
16687         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16688         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16689         { } /* end */
16690 };
16691
16692 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
16693  *                 Front Mic=0x18, ATAPI Mic = 0x19,
16694  */
16695 static const struct snd_kcontrol_new alc861vd_hp_mixer[] = {
16696         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16697         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16698         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16699         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16700         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16701         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16702         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16703         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16704
16705         { } /* end */
16706 };
16707
16708 /*
16709  * generic initialization of ADC, input mixers and output mixers
16710  */
16711 static const struct hda_verb alc861vd_volume_init_verbs[] = {
16712         /*
16713          * Unmute ADC0 and set the default input to mic-in
16714          */
16715         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16716         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16717
16718         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
16719          * the analog-loopback mixer widget
16720          */
16721         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16722         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16723         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16724         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16725         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16726         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16727
16728         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
16729         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16730         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16731         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
16732         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
16733
16734         /*
16735          * Set up output mixers (0x02 - 0x05)
16736          */
16737         /* set vol=0 to output mixers */
16738         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16739         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16740         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16741         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16742
16743         /* set up input amps for analog loopback */
16744         /* Amp Indices: DAC = 0, mixer = 1 */
16745         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16746         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16747         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16748         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16749         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16750         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16751         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16752         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16753
16754         { }
16755 };
16756
16757 /*
16758  * 3-stack pin configuration:
16759  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
16760  */
16761 static const struct hda_verb alc861vd_3stack_init_verbs[] = {
16762         /*
16763          * Set pin mode and muting
16764          */
16765         /* set front pin widgets 0x14 for output */
16766         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16767         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16768         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16769
16770         /* Mic (rear) pin: input vref at 80% */
16771         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16772         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16773         /* Front Mic pin: input vref at 80% */
16774         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16775         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16776         /* Line In pin: input */
16777         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16778         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16779         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16780         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16781         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16782         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16783         /* CD pin widget for input */
16784         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16785
16786         { }
16787 };
16788
16789 /*
16790  * 6-stack pin configuration:
16791  */
16792 static const struct hda_verb alc861vd_6stack_init_verbs[] = {
16793         /*
16794          * Set pin mode and muting
16795          */
16796         /* set front pin widgets 0x14 for output */
16797         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16798         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16799         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16800
16801         /* Rear Pin: output 1 (0x0d) */
16802         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16803         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16804         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16805         /* CLFE Pin: output 2 (0x0e) */
16806         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16807         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16808         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
16809         /* Side Pin: output 3 (0x0f) */
16810         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16811         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16812         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
16813
16814         /* Mic (rear) pin: input vref at 80% */
16815         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16816         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16817         /* Front Mic pin: input vref at 80% */
16818         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16819         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16820         /* Line In pin: input */
16821         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16822         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16823         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16824         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16825         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16826         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16827         /* CD pin widget for input */
16828         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16829
16830         { }
16831 };
16832
16833 static const struct hda_verb alc861vd_eapd_verbs[] = {
16834         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16835         { }
16836 };
16837
16838 static const struct hda_verb alc660vd_eapd_verbs[] = {
16839         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16840         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16841         { }
16842 };
16843
16844 static const struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
16845         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16846         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16847         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
16848         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16849         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16850         {}
16851 };
16852
16853 static void alc861vd_lenovo_setup(struct hda_codec *codec)
16854 {
16855         struct alc_spec *spec = codec->spec;
16856         spec->autocfg.hp_pins[0] = 0x1b;
16857         spec->autocfg.speaker_pins[0] = 0x14;
16858         spec->automute = 1;
16859         spec->automute_mode = ALC_AUTOMUTE_AMP;
16860 }
16861
16862 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
16863 {
16864         alc_hp_automute(codec);
16865         alc88x_simple_mic_automute(codec);
16866 }
16867
16868 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
16869                                         unsigned int res)
16870 {
16871         switch (res >> 26) {
16872         case ALC880_MIC_EVENT:
16873                 alc88x_simple_mic_automute(codec);
16874                 break;
16875         default:
16876                 alc_sku_unsol_event(codec, res);
16877                 break;
16878         }
16879 }
16880
16881 static const struct hda_verb alc861vd_dallas_verbs[] = {
16882         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16883         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16884         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16885         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16886
16887         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16888         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16889         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16890         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16891         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16892         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16893         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16894         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16895
16896         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16897         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16898         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16899         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16900         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16901         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16902         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16903         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16904
16905         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16906         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16907         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16908         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16909         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16910         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16911         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16912         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16913
16914         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16915         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16916         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16917         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16918
16919         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16920         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16921         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16922
16923         { } /* end */
16924 };
16925
16926 /* toggle speaker-output according to the hp-jack state */
16927 static void alc861vd_dallas_setup(struct hda_codec *codec)
16928 {
16929         struct alc_spec *spec = codec->spec;
16930
16931         spec->autocfg.hp_pins[0] = 0x15;
16932         spec->autocfg.speaker_pins[0] = 0x14;
16933         spec->automute = 1;
16934         spec->automute_mode = ALC_AUTOMUTE_AMP;
16935 }
16936
16937 #ifdef CONFIG_SND_HDA_POWER_SAVE
16938 #define alc861vd_loopbacks      alc880_loopbacks
16939 #endif
16940
16941 /* pcm configuration: identical with ALC880 */
16942 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
16943 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
16944 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
16945 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
16946
16947 /*
16948  * configuration and preset
16949  */
16950 static const char * const alc861vd_models[ALC861VD_MODEL_LAST] = {
16951         [ALC660VD_3ST]          = "3stack-660",
16952         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
16953         [ALC660VD_ASUS_V1S]     = "asus-v1s",
16954         [ALC861VD_3ST]          = "3stack",
16955         [ALC861VD_3ST_DIG]      = "3stack-digout",
16956         [ALC861VD_6ST_DIG]      = "6stack-digout",
16957         [ALC861VD_LENOVO]       = "lenovo",
16958         [ALC861VD_DALLAS]       = "dallas",
16959         [ALC861VD_HP]           = "hp",
16960         [ALC861VD_AUTO]         = "auto",
16961 };
16962
16963 static const struct snd_pci_quirk alc861vd_cfg_tbl[] = {
16964         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
16965         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
16966         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
16967         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
16968         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
16969         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
16970         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
16971         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
16972         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
16973         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
16974         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
16975         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
16976         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
16977         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
16978         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
16979         {}
16980 };
16981
16982 static const struct alc_config_preset alc861vd_presets[] = {
16983         [ALC660VD_3ST] = {
16984                 .mixers = { alc861vd_3st_mixer },
16985                 .init_verbs = { alc861vd_volume_init_verbs,
16986                                  alc861vd_3stack_init_verbs },
16987                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16988                 .dac_nids = alc660vd_dac_nids,
16989                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16990                 .channel_mode = alc861vd_3stack_2ch_modes,
16991                 .input_mux = &alc861vd_capture_source,
16992         },
16993         [ALC660VD_3ST_DIG] = {
16994                 .mixers = { alc861vd_3st_mixer },
16995                 .init_verbs = { alc861vd_volume_init_verbs,
16996                                  alc861vd_3stack_init_verbs },
16997                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16998                 .dac_nids = alc660vd_dac_nids,
16999                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17000                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17001                 .channel_mode = alc861vd_3stack_2ch_modes,
17002                 .input_mux = &alc861vd_capture_source,
17003         },
17004         [ALC861VD_3ST] = {
17005                 .mixers = { alc861vd_3st_mixer },
17006                 .init_verbs = { alc861vd_volume_init_verbs,
17007                                  alc861vd_3stack_init_verbs },
17008                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17009                 .dac_nids = alc861vd_dac_nids,
17010                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17011                 .channel_mode = alc861vd_3stack_2ch_modes,
17012                 .input_mux = &alc861vd_capture_source,
17013         },
17014         [ALC861VD_3ST_DIG] = {
17015                 .mixers = { alc861vd_3st_mixer },
17016                 .init_verbs = { alc861vd_volume_init_verbs,
17017                                  alc861vd_3stack_init_verbs },
17018                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17019                 .dac_nids = alc861vd_dac_nids,
17020                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17021                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17022                 .channel_mode = alc861vd_3stack_2ch_modes,
17023                 .input_mux = &alc861vd_capture_source,
17024         },
17025         [ALC861VD_6ST_DIG] = {
17026                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
17027                 .init_verbs = { alc861vd_volume_init_verbs,
17028                                 alc861vd_6stack_init_verbs },
17029                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17030                 .dac_nids = alc861vd_dac_nids,
17031                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17032                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
17033                 .channel_mode = alc861vd_6stack_modes,
17034                 .input_mux = &alc861vd_capture_source,
17035         },
17036         [ALC861VD_LENOVO] = {
17037                 .mixers = { alc861vd_lenovo_mixer },
17038                 .init_verbs = { alc861vd_volume_init_verbs,
17039                                 alc861vd_3stack_init_verbs,
17040                                 alc861vd_eapd_verbs,
17041                                 alc861vd_lenovo_unsol_verbs },
17042                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
17043                 .dac_nids = alc660vd_dac_nids,
17044                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17045                 .channel_mode = alc861vd_3stack_2ch_modes,
17046                 .input_mux = &alc861vd_capture_source,
17047                 .unsol_event = alc861vd_lenovo_unsol_event,
17048                 .setup = alc861vd_lenovo_setup,
17049                 .init_hook = alc861vd_lenovo_init_hook,
17050         },
17051         [ALC861VD_DALLAS] = {
17052                 .mixers = { alc861vd_dallas_mixer },
17053                 .init_verbs = { alc861vd_dallas_verbs },
17054                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17055                 .dac_nids = alc861vd_dac_nids,
17056                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17057                 .channel_mode = alc861vd_3stack_2ch_modes,
17058                 .input_mux = &alc861vd_dallas_capture_source,
17059                 .unsol_event = alc_sku_unsol_event,
17060                 .setup = alc861vd_dallas_setup,
17061                 .init_hook = alc_hp_automute,
17062         },
17063         [ALC861VD_HP] = {
17064                 .mixers = { alc861vd_hp_mixer },
17065                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
17066                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17067                 .dac_nids = alc861vd_dac_nids,
17068                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17069                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17070                 .channel_mode = alc861vd_3stack_2ch_modes,
17071                 .input_mux = &alc861vd_hp_capture_source,
17072                 .unsol_event = alc_sku_unsol_event,
17073                 .setup = alc861vd_dallas_setup,
17074                 .init_hook = alc_hp_automute,
17075         },
17076         [ALC660VD_ASUS_V1S] = {
17077                 .mixers = { alc861vd_lenovo_mixer },
17078                 .init_verbs = { alc861vd_volume_init_verbs,
17079                                 alc861vd_3stack_init_verbs,
17080                                 alc861vd_eapd_verbs,
17081                                 alc861vd_lenovo_unsol_verbs },
17082                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
17083                 .dac_nids = alc660vd_dac_nids,
17084                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17085                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17086                 .channel_mode = alc861vd_3stack_2ch_modes,
17087                 .input_mux = &alc861vd_capture_source,
17088                 .unsol_event = alc861vd_lenovo_unsol_event,
17089                 .setup = alc861vd_lenovo_setup,
17090                 .init_hook = alc861vd_lenovo_init_hook,
17091         },
17092 };
17093
17094 /*
17095  * BIOS auto configuration
17096  */
17097 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
17098                                                 const struct auto_pin_cfg *cfg)
17099 {
17100         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x22, 0);
17101 }
17102
17103
17104 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
17105                                 hda_nid_t nid, int pin_type, int dac_idx)
17106 {
17107         alc_set_pin_output(codec, nid, pin_type);
17108 }
17109
17110 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
17111 {
17112         struct alc_spec *spec = codec->spec;
17113         int i;
17114
17115         for (i = 0; i <= HDA_SIDE; i++) {
17116                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
17117                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
17118                 if (nid)
17119                         alc861vd_auto_set_output_and_unmute(codec, nid,
17120                                                             pin_type, i);
17121         }
17122 }
17123
17124
17125 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
17126 {
17127         struct alc_spec *spec = codec->spec;
17128         hda_nid_t pin;
17129
17130         pin = spec->autocfg.hp_pins[0];
17131         if (pin) /* connect to front and use dac 0 */
17132                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
17133         pin = spec->autocfg.speaker_pins[0];
17134         if (pin)
17135                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
17136 }
17137
17138 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
17139
17140 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
17141 {
17142         struct alc_spec *spec = codec->spec;
17143         struct auto_pin_cfg *cfg = &spec->autocfg;
17144         int i;
17145
17146         for (i = 0; i < cfg->num_inputs; i++) {
17147                 hda_nid_t nid = cfg->inputs[i].pin;
17148                 if (alc_is_input_pin(codec, nid)) {
17149                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
17150                         if (nid != ALC861VD_PIN_CD_NID &&
17151                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17152                                 snd_hda_codec_write(codec, nid, 0,
17153                                                 AC_VERB_SET_AMP_GAIN_MUTE,
17154                                                 AMP_OUT_MUTE);
17155                 }
17156         }
17157 }
17158
17159 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
17160
17161 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
17162 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
17163
17164 /* add playback controls from the parsed DAC table */
17165 /* Based on ALC880 version. But ALC861VD has separate,
17166  * different NIDs for mute/unmute switch and volume control */
17167 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
17168                                              const struct auto_pin_cfg *cfg)
17169 {
17170         static const char * const chname[4] = {
17171                 "Front", "Surround", "CLFE", "Side"
17172         };
17173         const char *pfx = alc_get_line_out_pfx(spec, true);
17174         hda_nid_t nid_v, nid_s;
17175         int i, err, noutputs;
17176
17177         noutputs = cfg->line_outs;
17178         if (spec->multi_ios > 0)
17179                 noutputs += spec->multi_ios;
17180
17181         for (i = 0; i < noutputs; i++) {
17182                 if (!spec->multiout.dac_nids[i])
17183                         continue;
17184                 nid_v = alc861vd_idx_to_mixer_vol(
17185                                 alc880_dac_to_idx(
17186                                         spec->multiout.dac_nids[i]));
17187                 nid_s = alc861vd_idx_to_mixer_switch(
17188                                 alc880_dac_to_idx(
17189                                         spec->multiout.dac_nids[i]));
17190
17191                 if (!pfx && i == 2) {
17192                         /* Center/LFE */
17193                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17194                                               "Center",
17195                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
17196                                                               HDA_OUTPUT));
17197                         if (err < 0)
17198                                 return err;
17199                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17200                                               "LFE",
17201                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
17202                                                               HDA_OUTPUT));
17203                         if (err < 0)
17204                                 return err;
17205                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17206                                              "Center",
17207                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
17208                                                               HDA_INPUT));
17209                         if (err < 0)
17210                                 return err;
17211                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17212                                              "LFE",
17213                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
17214                                                               HDA_INPUT));
17215                         if (err < 0)
17216                                 return err;
17217                 } else {
17218                         const char *name = pfx;
17219                         int index = i;
17220                         if (!name) {
17221                                 name = chname[i];
17222                                 index = 0;
17223                         }
17224                         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17225                                                 name, index,
17226                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
17227                                                               HDA_OUTPUT));
17228                         if (err < 0)
17229                                 return err;
17230                         err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17231                                                name, index,
17232                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
17233                                                               HDA_INPUT));
17234                         if (err < 0)
17235                                 return err;
17236                 }
17237         }
17238         return 0;
17239 }
17240
17241 /* add playback controls for speaker and HP outputs */
17242 /* Based on ALC880 version. But ALC861VD has separate,
17243  * different NIDs for mute/unmute switch and volume control */
17244 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
17245                                         hda_nid_t pin, const char *pfx)
17246 {
17247         hda_nid_t nid_v, nid_s;
17248         int err;
17249
17250         if (!pin)
17251                 return 0;
17252
17253         if (alc880_is_fixed_pin(pin)) {
17254                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
17255                 /* specify the DAC as the extra output */
17256                 if (!spec->multiout.hp_nid)
17257                         spec->multiout.hp_nid = nid_v;
17258                 else
17259                         spec->multiout.extra_out_nid[0] = nid_v;
17260                 /* control HP volume/switch on the output mixer amp */
17261                 nid_v = alc861vd_idx_to_mixer_vol(
17262                                 alc880_fixed_pin_idx(pin));
17263                 nid_s = alc861vd_idx_to_mixer_switch(
17264                                 alc880_fixed_pin_idx(pin));
17265
17266                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17267                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
17268                 if (err < 0)
17269                         return err;
17270                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17271                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
17272                 if (err < 0)
17273                         return err;
17274         } else if (alc880_is_multi_pin(pin)) {
17275                 /* set manual connection */
17276                 /* we have only a switch on HP-out PIN */
17277                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17278                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17279                 if (err < 0)
17280                         return err;
17281         }
17282         return 0;
17283 }
17284
17285 /* parse the BIOS configuration and set up the alc_spec
17286  * return 1 if successful, 0 if the proper config is not found,
17287  * or a negative error code
17288  * Based on ALC880 version - had to change it to override
17289  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
17290 static int alc861vd_parse_auto_config(struct hda_codec *codec)
17291 {
17292         struct alc_spec *spec = codec->spec;
17293         int err;
17294         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
17295
17296         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17297                                            alc861vd_ignore);
17298         if (err < 0)
17299                 return err;
17300         if (!spec->autocfg.line_outs)
17301                 return 0; /* can't find valid BIOS pin config */
17302
17303         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17304         if (err < 0)
17305                 return err;
17306         err = alc_auto_add_multi_channel_mode(codec);
17307         if (err < 0)
17308                 return err;
17309         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
17310         if (err < 0)
17311                 return err;
17312         err = alc861vd_auto_create_extra_out(spec,
17313                                              spec->autocfg.speaker_pins[0],
17314                                              "Speaker");
17315         if (err < 0)
17316                 return err;
17317         err = alc861vd_auto_create_extra_out(spec,
17318                                              spec->autocfg.hp_pins[0],
17319                                              "Headphone");
17320         if (err < 0)
17321                 return err;
17322         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
17323         if (err < 0)
17324                 return err;
17325
17326         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17327
17328         alc_auto_parse_digital(codec);
17329
17330         if (spec->kctls.list)
17331                 add_mixer(spec, spec->kctls.list);
17332
17333         add_verb(spec, alc861vd_volume_init_verbs);
17334
17335         spec->num_mux_defs = 1;
17336         spec->input_mux = &spec->private_imux[0];
17337
17338         err = alc_auto_add_mic_boost(codec);
17339         if (err < 0)
17340                 return err;
17341
17342         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
17343
17344         return 1;
17345 }
17346
17347 /* additional initialization for auto-configuration model */
17348 static void alc861vd_auto_init(struct hda_codec *codec)
17349 {
17350         struct alc_spec *spec = codec->spec;
17351         alc861vd_auto_init_multi_out(codec);
17352         alc861vd_auto_init_hp_out(codec);
17353         alc861vd_auto_init_analog_input(codec);
17354         alc861vd_auto_init_input_src(codec);
17355         alc_auto_init_digital(codec);
17356         if (spec->unsol_event)
17357                 alc_inithook(codec);
17358 }
17359
17360 enum {
17361         ALC660VD_FIX_ASUS_GPIO1
17362 };
17363
17364 /* reset GPIO1 */
17365 static const struct alc_fixup alc861vd_fixups[] = {
17366         [ALC660VD_FIX_ASUS_GPIO1] = {
17367                 .type = ALC_FIXUP_VERBS,
17368                 .v.verbs = (const struct hda_verb[]) {
17369                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
17370                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
17371                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
17372                         { }
17373                 }
17374         },
17375 };
17376
17377 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
17378         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
17379         {}
17380 };
17381
17382 static int patch_alc861vd(struct hda_codec *codec)
17383 {
17384         struct alc_spec *spec;
17385         int err, board_config;
17386
17387         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17388         if (spec == NULL)
17389                 return -ENOMEM;
17390
17391         codec->spec = spec;
17392
17393         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
17394                                                   alc861vd_models,
17395                                                   alc861vd_cfg_tbl);
17396
17397         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
17398                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17399                        codec->chip_name);
17400                 board_config = ALC861VD_AUTO;
17401         }
17402
17403         if (board_config == ALC861VD_AUTO) {
17404                 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
17405                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
17406         }
17407
17408         if (board_config == ALC861VD_AUTO) {
17409                 /* automatic parse from the BIOS config */
17410                 err = alc861vd_parse_auto_config(codec);
17411                 if (err < 0) {
17412                         alc_free(codec);
17413                         return err;
17414                 } else if (!err) {
17415                         printk(KERN_INFO
17416                                "hda_codec: Cannot set up configuration "
17417                                "from BIOS.  Using base mode...\n");
17418                         board_config = ALC861VD_3ST;
17419                 }
17420         }
17421
17422         err = snd_hda_attach_beep_device(codec, 0x23);
17423         if (err < 0) {
17424                 alc_free(codec);
17425                 return err;
17426         }
17427
17428         if (board_config != ALC861VD_AUTO)
17429                 setup_preset(codec, &alc861vd_presets[board_config]);
17430
17431         if (codec->vendor_id == 0x10ec0660) {
17432                 /* always turn on EAPD */
17433                 add_verb(spec, alc660vd_eapd_verbs);
17434         }
17435
17436         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
17437         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
17438
17439         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
17440         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
17441
17442         if (!spec->adc_nids) {
17443                 spec->adc_nids = alc861vd_adc_nids;
17444                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
17445         }
17446         if (!spec->capsrc_nids)
17447                 spec->capsrc_nids = alc861vd_capsrc_nids;
17448
17449         set_capture_mixer(codec);
17450         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17451
17452         spec->vmaster_nid = 0x02;
17453
17454         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
17455
17456         codec->patch_ops = alc_patch_ops;
17457
17458         if (board_config == ALC861VD_AUTO)
17459                 spec->init_hook = alc861vd_auto_init;
17460         spec->shutup = alc_eapd_shutup;
17461 #ifdef CONFIG_SND_HDA_POWER_SAVE
17462         if (!spec->loopback.amplist)
17463                 spec->loopback.amplist = alc861vd_loopbacks;
17464 #endif
17465
17466         return 0;
17467 }
17468
17469 /*
17470  * ALC662 support
17471  *
17472  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
17473  * configuration.  Each pin widget can choose any input DACs and a mixer.
17474  * Each ADC is connected from a mixer of all inputs.  This makes possible
17475  * 6-channel independent captures.
17476  *
17477  * In addition, an independent DAC for the multi-playback (not used in this
17478  * driver yet).
17479  */
17480 #define ALC662_DIGOUT_NID       0x06
17481 #define ALC662_DIGIN_NID        0x0a
17482
17483 static const hda_nid_t alc662_dac_nids[3] = {
17484         /* front, rear, clfe */
17485         0x02, 0x03, 0x04
17486 };
17487
17488 static const hda_nid_t alc272_dac_nids[2] = {
17489         0x02, 0x03
17490 };
17491
17492 static const hda_nid_t alc662_adc_nids[2] = {
17493         /* ADC1-2 */
17494         0x09, 0x08
17495 };
17496
17497 static const hda_nid_t alc272_adc_nids[1] = {
17498         /* ADC1-2 */
17499         0x08,
17500 };
17501
17502 static const hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
17503 static const hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
17504
17505
17506 /* input MUX */
17507 /* FIXME: should be a matrix-type input source selection */
17508 static const struct hda_input_mux alc662_capture_source = {
17509         .num_items = 4,
17510         .items = {
17511                 { "Mic", 0x0 },
17512                 { "Front Mic", 0x1 },
17513                 { "Line", 0x2 },
17514                 { "CD", 0x4 },
17515         },
17516 };
17517
17518 static const struct hda_input_mux alc662_lenovo_101e_capture_source = {
17519         .num_items = 2,
17520         .items = {
17521                 { "Mic", 0x1 },
17522                 { "Line", 0x2 },
17523         },
17524 };
17525
17526 static const struct hda_input_mux alc663_capture_source = {
17527         .num_items = 3,
17528         .items = {
17529                 { "Mic", 0x0 },
17530                 { "Front Mic", 0x1 },
17531                 { "Line", 0x2 },
17532         },
17533 };
17534
17535 #if 0 /* set to 1 for testing other input sources below */
17536 static const struct hda_input_mux alc272_nc10_capture_source = {
17537         .num_items = 16,
17538         .items = {
17539                 { "Autoselect Mic", 0x0 },
17540                 { "Internal Mic", 0x1 },
17541                 { "In-0x02", 0x2 },
17542                 { "In-0x03", 0x3 },
17543                 { "In-0x04", 0x4 },
17544                 { "In-0x05", 0x5 },
17545                 { "In-0x06", 0x6 },
17546                 { "In-0x07", 0x7 },
17547                 { "In-0x08", 0x8 },
17548                 { "In-0x09", 0x9 },
17549                 { "In-0x0a", 0x0a },
17550                 { "In-0x0b", 0x0b },
17551                 { "In-0x0c", 0x0c },
17552                 { "In-0x0d", 0x0d },
17553                 { "In-0x0e", 0x0e },
17554                 { "In-0x0f", 0x0f },
17555         },
17556 };
17557 #endif
17558
17559 /*
17560  * 2ch mode
17561  */
17562 static const struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
17563         { 2, NULL }
17564 };
17565
17566 /*
17567  * 2ch mode
17568  */
17569 static const struct hda_verb alc662_3ST_ch2_init[] = {
17570         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
17571         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17572         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
17573         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17574         { } /* end */
17575 };
17576
17577 /*
17578  * 6ch mode
17579  */
17580 static const struct hda_verb alc662_3ST_ch6_init[] = {
17581         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17582         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17583         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
17584         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17585         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17586         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
17587         { } /* end */
17588 };
17589
17590 static const struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
17591         { 2, alc662_3ST_ch2_init },
17592         { 6, alc662_3ST_ch6_init },
17593 };
17594
17595 /*
17596  * 2ch mode
17597  */
17598 static const struct hda_verb alc662_sixstack_ch6_init[] = {
17599         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17600         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17601         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17602         { } /* end */
17603 };
17604
17605 /*
17606  * 6ch mode
17607  */
17608 static const struct hda_verb alc662_sixstack_ch8_init[] = {
17609         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17610         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17611         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17612         { } /* end */
17613 };
17614
17615 static const struct hda_channel_mode alc662_5stack_modes[2] = {
17616         { 2, alc662_sixstack_ch6_init },
17617         { 6, alc662_sixstack_ch8_init },
17618 };
17619
17620 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
17621  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
17622  */
17623
17624 static const struct snd_kcontrol_new alc662_base_mixer[] = {
17625         /* output mixer control */
17626         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
17627         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17628         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
17629         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17630         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17631         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17632         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17633         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17634         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17635
17636         /*Input mixer control */
17637         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
17638         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
17639         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
17640         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
17641         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
17642         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
17643         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
17644         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
17645         { } /* end */
17646 };
17647
17648 static const struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
17649         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17650         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17651         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17652         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17653         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17654         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17655         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17656         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17657         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17658         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17659         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17660         { } /* end */
17661 };
17662
17663 static const struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
17664         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17665         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17666         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17667         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17668         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17669         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17670         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17671         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17672         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17673         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17674         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17675         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17676         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17677         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17678         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17679         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17680         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17681         { } /* end */
17682 };
17683
17684 static const struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
17685         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17686         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
17687         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17688         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
17689         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17690         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17691         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17692         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17693         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17694         { } /* end */
17695 };
17696
17697 static const struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
17698         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17699         ALC262_HIPPO_MASTER_SWITCH,
17700
17701         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
17702         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17703         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17704
17705         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
17706         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17707         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17708         { } /* end */
17709 };
17710
17711 static const struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
17712         ALC262_HIPPO_MASTER_SWITCH,
17713         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17714         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17715         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17716         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17717         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
17718         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17719         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17720         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17721         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17722         { } /* end */
17723 };
17724
17725 static const struct hda_bind_ctls alc663_asus_bind_master_vol = {
17726         .ops = &snd_hda_bind_vol,
17727         .values = {
17728                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17729                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
17730                 0
17731         },
17732 };
17733
17734 static const struct hda_bind_ctls alc663_asus_one_bind_switch = {
17735         .ops = &snd_hda_bind_sw,
17736         .values = {
17737                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17738                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17739                 0
17740         },
17741 };
17742
17743 static const struct snd_kcontrol_new alc663_m51va_mixer[] = {
17744         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17745         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
17746         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17747         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17748         { } /* end */
17749 };
17750
17751 static const struct hda_bind_ctls alc663_asus_tree_bind_switch = {
17752         .ops = &snd_hda_bind_sw,
17753         .values = {
17754                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17755                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17756                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17757                 0
17758         },
17759 };
17760
17761 static const struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
17762         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17763         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
17764         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17765         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17766         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17767         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17768
17769         { } /* end */
17770 };
17771
17772 static const struct hda_bind_ctls alc663_asus_four_bind_switch = {
17773         .ops = &snd_hda_bind_sw,
17774         .values = {
17775                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17776                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17777                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17778                 0
17779         },
17780 };
17781
17782 static const struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
17783         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17784         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
17785         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17786         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17787         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17788         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17789         { } /* end */
17790 };
17791
17792 static const struct snd_kcontrol_new alc662_1bjd_mixer[] = {
17793         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17794         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17795         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17796         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17797         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17798         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17799         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17800         { } /* end */
17801 };
17802
17803 static const struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
17804         .ops = &snd_hda_bind_vol,
17805         .values = {
17806                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17807                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
17808                 0
17809         },
17810 };
17811
17812 static const struct hda_bind_ctls alc663_asus_two_bind_switch = {
17813         .ops = &snd_hda_bind_sw,
17814         .values = {
17815                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17816                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
17817                 0
17818         },
17819 };
17820
17821 static const struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
17822         HDA_BIND_VOL("Master Playback Volume",
17823                                 &alc663_asus_two_bind_master_vol),
17824         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17825         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17826         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17827         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17828         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17829         { } /* end */
17830 };
17831
17832 static const struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
17833         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17834         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17835         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17836         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17837         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17838         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17839         { } /* end */
17840 };
17841
17842 static const struct snd_kcontrol_new alc663_g71v_mixer[] = {
17843         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17844         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17845         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17846         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17847         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17848
17849         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17850         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17851         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17852         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17853         { } /* end */
17854 };
17855
17856 static const struct snd_kcontrol_new alc663_g50v_mixer[] = {
17857         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17858         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17859         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17860
17861         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17862         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17863         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17864         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17865         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17866         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17867         { } /* end */
17868 };
17869
17870 static const struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
17871         .ops = &snd_hda_bind_sw,
17872         .values = {
17873                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17874                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17875                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17876                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17877                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17878                 0
17879         },
17880 };
17881
17882 static const struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
17883         .ops = &snd_hda_bind_sw,
17884         .values = {
17885                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17886                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17887                 0
17888         },
17889 };
17890
17891 static const struct snd_kcontrol_new alc663_mode7_mixer[] = {
17892         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17893         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17894         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17895         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17896         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17897         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17898         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17899         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17900         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17901         { } /* end */
17902 };
17903
17904 static const struct snd_kcontrol_new alc663_mode8_mixer[] = {
17905         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17906         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17907         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17908         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17909         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17910         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17911         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17912         { } /* end */
17913 };
17914
17915
17916 static const struct snd_kcontrol_new alc662_chmode_mixer[] = {
17917         {
17918                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
17919                 .name = "Channel Mode",
17920                 .info = alc_ch_mode_info,
17921                 .get = alc_ch_mode_get,
17922                 .put = alc_ch_mode_put,
17923         },
17924         { } /* end */
17925 };
17926
17927 static const struct hda_verb alc662_init_verbs[] = {
17928         /* ADC: mute amp left and right */
17929         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17930         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
17931
17932         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17933         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17934         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17935         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17936         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17937         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17938
17939         /* Front Pin: output 0 (0x0c) */
17940         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17941         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17942
17943         /* Rear Pin: output 1 (0x0d) */
17944         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17945         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17946
17947         /* CLFE Pin: output 2 (0x0e) */
17948         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17949         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17950
17951         /* Mic (rear) pin: input vref at 80% */
17952         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17953         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17954         /* Front Mic pin: input vref at 80% */
17955         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17956         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17957         /* Line In pin: input */
17958         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17959         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17960         /* Line-2 In: Headphone output (output 0 - 0x0c) */
17961         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17962         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17963         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
17964         /* CD pin widget for input */
17965         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17966
17967         /* FIXME: use matrix-type input source selection */
17968         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
17969         /* Input mixer */
17970         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17971         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17972
17973         { }
17974 };
17975
17976 static const struct hda_verb alc662_eapd_init_verbs[] = {
17977         /* always trun on EAPD */
17978         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
17979         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
17980         { }
17981 };
17982
17983 static const struct hda_verb alc662_sue_init_verbs[] = {
17984         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17985         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17986         {}
17987 };
17988
17989 static const struct hda_verb alc662_eeepc_sue_init_verbs[] = {
17990         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17991         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17992         {}
17993 };
17994
17995 /* Set Unsolicited Event*/
17996 static const struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
17997         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17998         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17999         {}
18000 };
18001
18002 static const struct hda_verb alc663_m51va_init_verbs[] = {
18003         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18004         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18005         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18006         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18007         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18008         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18009         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18010         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18011         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18012         {}
18013 };
18014
18015 static const struct hda_verb alc663_21jd_amic_init_verbs[] = {
18016         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18017         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18018         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18019         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18020         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18021         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18022         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18023         {}
18024 };
18025
18026 static const struct hda_verb alc662_1bjd_amic_init_verbs[] = {
18027         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18028         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18029         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18030         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
18031         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18032         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18033         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18034         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18035         {}
18036 };
18037
18038 static const struct hda_verb alc663_15jd_amic_init_verbs[] = {
18039         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18040         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18041         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18042         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18043         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18044         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18045         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18046         {}
18047 };
18048
18049 static const struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
18050         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18051         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18052         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18053         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
18054         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18055         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18056         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
18057         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18058         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18059         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18060         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18061         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18062         {}
18063 };
18064
18065 static const struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
18066         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18067         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18068         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18069         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18070         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18071         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18072         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18073         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18074         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18075         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18076         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18077         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18078         {}
18079 };
18080
18081 static const struct hda_verb alc663_g71v_init_verbs[] = {
18082         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18083         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
18084         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
18085
18086         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18087         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18088         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
18089
18090         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
18091         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
18092         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
18093         {}
18094 };
18095
18096 static const struct hda_verb alc663_g50v_init_verbs[] = {
18097         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18098         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18099         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
18100
18101         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18102         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18103         {}
18104 };
18105
18106 static const struct hda_verb alc662_ecs_init_verbs[] = {
18107         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
18108         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18109         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18110         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18111         {}
18112 };
18113
18114 static const struct hda_verb alc272_dell_zm1_init_verbs[] = {
18115         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18116         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18117         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18118         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18119         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18120         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18121         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18122         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18123         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18124         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18125         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18126         {}
18127 };
18128
18129 static const struct hda_verb alc272_dell_init_verbs[] = {
18130         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18131         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18132         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18133         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18134         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18135         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18136         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18137         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18138         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18139         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18140         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18141         {}
18142 };
18143
18144 static const struct hda_verb alc663_mode7_init_verbs[] = {
18145         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18146         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18147         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18148         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18149         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18150         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18151         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
18152         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18153         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18154         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18155         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18156         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18157         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18158         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18159         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18160         {}
18161 };
18162
18163 static const struct hda_verb alc663_mode8_init_verbs[] = {
18164         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18165         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18166         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18167         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
18168         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18169         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18170         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18171         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18172         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18173         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18174         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18175         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18176         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18177         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18178         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18179         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18180         {}
18181 };
18182
18183 static const struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
18184         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
18185         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
18186         { } /* end */
18187 };
18188
18189 static const struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
18190         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
18191         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
18192         { } /* end */
18193 };
18194
18195 static void alc662_lenovo_101e_setup(struct hda_codec *codec)
18196 {
18197         struct alc_spec *spec = codec->spec;
18198
18199         spec->autocfg.hp_pins[0] = 0x1b;
18200         spec->autocfg.line_out_pins[0] = 0x14;
18201         spec->autocfg.speaker_pins[0] = 0x15;
18202         spec->automute = 1;
18203         spec->detect_line = 1;
18204         spec->automute_lines = 1;
18205         spec->automute_mode = ALC_AUTOMUTE_AMP;
18206 }
18207
18208 static void alc662_eeepc_setup(struct hda_codec *codec)
18209 {
18210         struct alc_spec *spec = codec->spec;
18211
18212         alc262_hippo1_setup(codec);
18213         spec->ext_mic.pin = 0x18;
18214         spec->ext_mic.mux_idx = 0;
18215         spec->int_mic.pin = 0x19;
18216         spec->int_mic.mux_idx = 1;
18217         spec->auto_mic = 1;
18218 }
18219
18220 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
18221 {
18222         struct alc_spec *spec = codec->spec;
18223
18224         spec->autocfg.hp_pins[0] = 0x14;
18225         spec->autocfg.speaker_pins[0] = 0x1b;
18226         spec->automute = 1;
18227         spec->automute_mode = ALC_AUTOMUTE_AMP;
18228 }
18229
18230 static void alc663_m51va_setup(struct hda_codec *codec)
18231 {
18232         struct alc_spec *spec = codec->spec;
18233         spec->autocfg.hp_pins[0] = 0x21;
18234         spec->autocfg.speaker_pins[0] = 0x14;
18235         spec->automute_mixer_nid[0] = 0x0c;
18236         spec->automute = 1;
18237         spec->automute_mode = ALC_AUTOMUTE_MIXER;
18238         spec->ext_mic.pin = 0x18;
18239         spec->ext_mic.mux_idx = 0;
18240         spec->int_mic.pin = 0x12;
18241         spec->int_mic.mux_idx = 9;
18242         spec->auto_mic = 1;
18243 }
18244
18245 /* ***************** Mode1 ******************************/
18246 static void alc663_mode1_setup(struct hda_codec *codec)
18247 {
18248         struct alc_spec *spec = codec->spec;
18249         spec->autocfg.hp_pins[0] = 0x21;
18250         spec->autocfg.speaker_pins[0] = 0x14;
18251         spec->automute_mixer_nid[0] = 0x0c;
18252         spec->automute = 1;
18253         spec->automute_mode = ALC_AUTOMUTE_MIXER;
18254         spec->ext_mic.pin = 0x18;
18255         spec->ext_mic.mux_idx = 0;
18256         spec->int_mic.pin = 0x19;
18257         spec->int_mic.mux_idx = 1;
18258         spec->auto_mic = 1;
18259 }
18260
18261 /* ***************** Mode2 ******************************/
18262 static void alc662_mode2_setup(struct hda_codec *codec)
18263 {
18264         struct alc_spec *spec = codec->spec;
18265         spec->autocfg.hp_pins[0] = 0x1b;
18266         spec->autocfg.speaker_pins[0] = 0x14;
18267         spec->automute = 1;
18268         spec->automute_mode = ALC_AUTOMUTE_PIN;
18269         spec->ext_mic.pin = 0x18;
18270         spec->ext_mic.mux_idx = 0;
18271         spec->int_mic.pin = 0x19;
18272         spec->int_mic.mux_idx = 1;
18273         spec->auto_mic = 1;
18274 }
18275
18276 /* ***************** Mode3 ******************************/
18277 static void alc663_mode3_setup(struct hda_codec *codec)
18278 {
18279         struct alc_spec *spec = codec->spec;
18280         spec->autocfg.hp_pins[0] = 0x21;
18281         spec->autocfg.hp_pins[0] = 0x15;
18282         spec->autocfg.speaker_pins[0] = 0x14;
18283         spec->automute = 1;
18284         spec->automute_mode = ALC_AUTOMUTE_PIN;
18285         spec->ext_mic.pin = 0x18;
18286         spec->ext_mic.mux_idx = 0;
18287         spec->int_mic.pin = 0x19;
18288         spec->int_mic.mux_idx = 1;
18289         spec->auto_mic = 1;
18290 }
18291
18292 /* ***************** Mode4 ******************************/
18293 static void alc663_mode4_setup(struct hda_codec *codec)
18294 {
18295         struct alc_spec *spec = codec->spec;
18296         spec->autocfg.hp_pins[0] = 0x21;
18297         spec->autocfg.speaker_pins[0] = 0x14;
18298         spec->autocfg.speaker_pins[1] = 0x16;
18299         spec->automute_mixer_nid[0] = 0x0c;
18300         spec->automute_mixer_nid[1] = 0x0e;
18301         spec->automute = 1;
18302         spec->automute_mode = ALC_AUTOMUTE_MIXER;
18303         spec->ext_mic.pin = 0x18;
18304         spec->ext_mic.mux_idx = 0;
18305         spec->int_mic.pin = 0x19;
18306         spec->int_mic.mux_idx = 1;
18307         spec->auto_mic = 1;
18308 }
18309
18310 /* ***************** Mode5 ******************************/
18311 static void alc663_mode5_setup(struct hda_codec *codec)
18312 {
18313         struct alc_spec *spec = codec->spec;
18314         spec->autocfg.hp_pins[0] = 0x15;
18315         spec->autocfg.speaker_pins[0] = 0x14;
18316         spec->autocfg.speaker_pins[1] = 0x16;
18317         spec->automute_mixer_nid[0] = 0x0c;
18318         spec->automute_mixer_nid[1] = 0x0e;
18319         spec->automute = 1;
18320         spec->automute_mode = ALC_AUTOMUTE_MIXER;
18321         spec->ext_mic.pin = 0x18;
18322         spec->ext_mic.mux_idx = 0;
18323         spec->int_mic.pin = 0x19;
18324         spec->int_mic.mux_idx = 1;
18325         spec->auto_mic = 1;
18326 }
18327
18328 /* ***************** Mode6 ******************************/
18329 static void alc663_mode6_setup(struct hda_codec *codec)
18330 {
18331         struct alc_spec *spec = codec->spec;
18332         spec->autocfg.hp_pins[0] = 0x1b;
18333         spec->autocfg.hp_pins[0] = 0x15;
18334         spec->autocfg.speaker_pins[0] = 0x14;
18335         spec->automute_mixer_nid[0] = 0x0c;
18336         spec->automute = 1;
18337         spec->automute_mode = ALC_AUTOMUTE_MIXER;
18338         spec->ext_mic.pin = 0x18;
18339         spec->ext_mic.mux_idx = 0;
18340         spec->int_mic.pin = 0x19;
18341         spec->int_mic.mux_idx = 1;
18342         spec->auto_mic = 1;
18343 }
18344
18345 /* ***************** Mode7 ******************************/
18346 static void alc663_mode7_setup(struct hda_codec *codec)
18347 {
18348         struct alc_spec *spec = codec->spec;
18349         spec->autocfg.hp_pins[0] = 0x1b;
18350         spec->autocfg.hp_pins[0] = 0x21;
18351         spec->autocfg.speaker_pins[0] = 0x14;
18352         spec->autocfg.speaker_pins[0] = 0x17;
18353         spec->automute = 1;
18354         spec->automute_mode = ALC_AUTOMUTE_PIN;
18355         spec->ext_mic.pin = 0x18;
18356         spec->ext_mic.mux_idx = 0;
18357         spec->int_mic.pin = 0x19;
18358         spec->int_mic.mux_idx = 1;
18359         spec->auto_mic = 1;
18360 }
18361
18362 /* ***************** Mode8 ******************************/
18363 static void alc663_mode8_setup(struct hda_codec *codec)
18364 {
18365         struct alc_spec *spec = codec->spec;
18366         spec->autocfg.hp_pins[0] = 0x21;
18367         spec->autocfg.hp_pins[1] = 0x15;
18368         spec->autocfg.speaker_pins[0] = 0x14;
18369         spec->autocfg.speaker_pins[0] = 0x17;
18370         spec->automute = 1;
18371         spec->automute_mode = ALC_AUTOMUTE_PIN;
18372         spec->ext_mic.pin = 0x18;
18373         spec->ext_mic.mux_idx = 0;
18374         spec->int_mic.pin = 0x12;
18375         spec->int_mic.mux_idx = 9;
18376         spec->auto_mic = 1;
18377 }
18378
18379 static void alc663_g71v_setup(struct hda_codec *codec)
18380 {
18381         struct alc_spec *spec = codec->spec;
18382         spec->autocfg.hp_pins[0] = 0x21;
18383         spec->autocfg.line_out_pins[0] = 0x15;
18384         spec->autocfg.speaker_pins[0] = 0x14;
18385         spec->automute = 1;
18386         spec->automute_mode = ALC_AUTOMUTE_AMP;
18387         spec->detect_line = 1;
18388         spec->automute_lines = 1;
18389         spec->ext_mic.pin = 0x18;
18390         spec->ext_mic.mux_idx = 0;
18391         spec->int_mic.pin = 0x12;
18392         spec->int_mic.mux_idx = 9;
18393         spec->auto_mic = 1;
18394 }
18395
18396 #define alc663_g50v_setup       alc663_m51va_setup
18397
18398 static const struct snd_kcontrol_new alc662_ecs_mixer[] = {
18399         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18400         ALC262_HIPPO_MASTER_SWITCH,
18401
18402         HDA_CODEC_VOLUME("Mic/LineIn Boost Volume", 0x18, 0, HDA_INPUT),
18403         HDA_CODEC_VOLUME("Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
18404         HDA_CODEC_MUTE("Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
18405
18406         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
18407         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18408         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18409         { } /* end */
18410 };
18411
18412 static const struct snd_kcontrol_new alc272_nc10_mixer[] = {
18413         /* Master Playback automatically created from Speaker and Headphone */
18414         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18415         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
18416         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
18417         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
18418
18419         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
18420         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
18421         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
18422
18423         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18424         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18425         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
18426         { } /* end */
18427 };
18428
18429 #ifdef CONFIG_SND_HDA_POWER_SAVE
18430 #define alc662_loopbacks        alc880_loopbacks
18431 #endif
18432
18433
18434 /* pcm configuration: identical with ALC880 */
18435 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
18436 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
18437 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
18438 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
18439
18440 /*
18441  * configuration and preset
18442  */
18443 static const char * const alc662_models[ALC662_MODEL_LAST] = {
18444         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
18445         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
18446         [ALC662_3ST_6ch]        = "3stack-6ch",
18447         [ALC662_5ST_DIG]        = "5stack-dig",
18448         [ALC662_LENOVO_101E]    = "lenovo-101e",
18449         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
18450         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
18451         [ALC662_ECS] = "ecs",
18452         [ALC663_ASUS_M51VA] = "m51va",
18453         [ALC663_ASUS_G71V] = "g71v",
18454         [ALC663_ASUS_H13] = "h13",
18455         [ALC663_ASUS_G50V] = "g50v",
18456         [ALC663_ASUS_MODE1] = "asus-mode1",
18457         [ALC662_ASUS_MODE2] = "asus-mode2",
18458         [ALC663_ASUS_MODE3] = "asus-mode3",
18459         [ALC663_ASUS_MODE4] = "asus-mode4",
18460         [ALC663_ASUS_MODE5] = "asus-mode5",
18461         [ALC663_ASUS_MODE6] = "asus-mode6",
18462         [ALC663_ASUS_MODE7] = "asus-mode7",
18463         [ALC663_ASUS_MODE8] = "asus-mode8",
18464         [ALC272_DELL]           = "dell",
18465         [ALC272_DELL_ZM1]       = "dell-zm1",
18466         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
18467         [ALC662_AUTO]           = "auto",
18468 };
18469
18470 static const struct snd_pci_quirk alc662_cfg_tbl[] = {
18471         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
18472         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
18473         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
18474         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
18475         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
18476         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
18477         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
18478         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
18479         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
18480         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
18481         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
18482         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
18483         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
18484         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
18485         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
18486         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
18487         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
18488         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
18489         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
18490         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
18491         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
18492         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
18493         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
18494         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
18495         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
18496         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
18497         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
18498         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
18499         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
18500         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
18501         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
18502         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
18503         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
18504         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
18505         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
18506         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
18507         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
18508         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
18509         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
18510         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
18511         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
18512         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
18513         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
18514         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
18515         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
18516         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
18517         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
18518         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
18519         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
18520         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
18521         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
18522         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
18523         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
18524         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
18525         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
18526         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
18527         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
18528         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
18529         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
18530         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
18531         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
18532         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
18533         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
18534         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
18535                       ALC662_3ST_6ch_DIG),
18536         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
18537         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
18538         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
18539                       ALC662_3ST_6ch_DIG),
18540         SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
18541         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
18542         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
18543         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
18544         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
18545                                         ALC662_3ST_6ch_DIG),
18546         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
18547                            ALC663_ASUS_H13),
18548         SND_PCI_QUIRK(0x1991, 0x5628, "Ordissimo EVE", ALC662_LENOVO_101E),
18549         {}
18550 };
18551
18552 static const struct alc_config_preset alc662_presets[] = {
18553         [ALC662_3ST_2ch_DIG] = {
18554                 .mixers = { alc662_3ST_2ch_mixer },
18555                 .init_verbs = { alc662_init_verbs, alc662_eapd_init_verbs },
18556                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18557                 .dac_nids = alc662_dac_nids,
18558                 .dig_out_nid = ALC662_DIGOUT_NID,
18559                 .dig_in_nid = ALC662_DIGIN_NID,
18560                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18561                 .channel_mode = alc662_3ST_2ch_modes,
18562                 .input_mux = &alc662_capture_source,
18563         },
18564         [ALC662_3ST_6ch_DIG] = {
18565                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18566                 .init_verbs = { alc662_init_verbs, alc662_eapd_init_verbs },
18567                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18568                 .dac_nids = alc662_dac_nids,
18569                 .dig_out_nid = ALC662_DIGOUT_NID,
18570                 .dig_in_nid = ALC662_DIGIN_NID,
18571                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18572                 .channel_mode = alc662_3ST_6ch_modes,
18573                 .need_dac_fix = 1,
18574                 .input_mux = &alc662_capture_source,
18575         },
18576         [ALC662_3ST_6ch] = {
18577                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18578                 .init_verbs = { alc662_init_verbs, alc662_eapd_init_verbs },
18579                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18580                 .dac_nids = alc662_dac_nids,
18581                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18582                 .channel_mode = alc662_3ST_6ch_modes,
18583                 .need_dac_fix = 1,
18584                 .input_mux = &alc662_capture_source,
18585         },
18586         [ALC662_5ST_DIG] = {
18587                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
18588                 .init_verbs = { alc662_init_verbs, alc662_eapd_init_verbs },
18589                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18590                 .dac_nids = alc662_dac_nids,
18591                 .dig_out_nid = ALC662_DIGOUT_NID,
18592                 .dig_in_nid = ALC662_DIGIN_NID,
18593                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
18594                 .channel_mode = alc662_5stack_modes,
18595                 .input_mux = &alc662_capture_source,
18596         },
18597         [ALC662_LENOVO_101E] = {
18598                 .mixers = { alc662_lenovo_101e_mixer },
18599                 .init_verbs = { alc662_init_verbs,
18600                                 alc662_eapd_init_verbs,
18601                                 alc662_sue_init_verbs },
18602                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18603                 .dac_nids = alc662_dac_nids,
18604                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18605                 .channel_mode = alc662_3ST_2ch_modes,
18606                 .input_mux = &alc662_lenovo_101e_capture_source,
18607                 .unsol_event = alc_sku_unsol_event,
18608                 .setup = alc662_lenovo_101e_setup,
18609                 .init_hook = alc_inithook,
18610         },
18611         [ALC662_ASUS_EEEPC_P701] = {
18612                 .mixers = { alc662_eeepc_p701_mixer },
18613                 .init_verbs = { alc662_init_verbs,
18614                                 alc662_eapd_init_verbs,
18615                                 alc662_eeepc_sue_init_verbs },
18616                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18617                 .dac_nids = alc662_dac_nids,
18618                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18619                 .channel_mode = alc662_3ST_2ch_modes,
18620                 .unsol_event = alc_sku_unsol_event,
18621                 .setup = alc662_eeepc_setup,
18622                 .init_hook = alc_inithook,
18623         },
18624         [ALC662_ASUS_EEEPC_EP20] = {
18625                 .mixers = { alc662_eeepc_ep20_mixer,
18626                             alc662_chmode_mixer },
18627                 .init_verbs = { alc662_init_verbs,
18628                                 alc662_eapd_init_verbs,
18629                                 alc662_eeepc_ep20_sue_init_verbs },
18630                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18631                 .dac_nids = alc662_dac_nids,
18632                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18633                 .channel_mode = alc662_3ST_6ch_modes,
18634                 .input_mux = &alc662_lenovo_101e_capture_source,
18635                 .unsol_event = alc_sku_unsol_event,
18636                 .setup = alc662_eeepc_ep20_setup,
18637                 .init_hook = alc_inithook,
18638         },
18639         [ALC662_ECS] = {
18640                 .mixers = { alc662_ecs_mixer },
18641                 .init_verbs = { alc662_init_verbs,
18642                                 alc662_eapd_init_verbs,
18643                                 alc662_ecs_init_verbs },
18644                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18645                 .dac_nids = alc662_dac_nids,
18646                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18647                 .channel_mode = alc662_3ST_2ch_modes,
18648                 .unsol_event = alc_sku_unsol_event,
18649                 .setup = alc662_eeepc_setup,
18650                 .init_hook = alc_inithook,
18651         },
18652         [ALC663_ASUS_M51VA] = {
18653                 .mixers = { alc663_m51va_mixer },
18654                 .init_verbs = { alc662_init_verbs,
18655                                 alc662_eapd_init_verbs,
18656                                 alc663_m51va_init_verbs },
18657                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18658                 .dac_nids = alc662_dac_nids,
18659                 .dig_out_nid = ALC662_DIGOUT_NID,
18660                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18661                 .channel_mode = alc662_3ST_2ch_modes,
18662                 .unsol_event = alc_sku_unsol_event,
18663                 .setup = alc663_m51va_setup,
18664                 .init_hook = alc_inithook,
18665         },
18666         [ALC663_ASUS_G71V] = {
18667                 .mixers = { alc663_g71v_mixer },
18668                 .init_verbs = { alc662_init_verbs,
18669                                 alc662_eapd_init_verbs,
18670                                 alc663_g71v_init_verbs },
18671                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18672                 .dac_nids = alc662_dac_nids,
18673                 .dig_out_nid = ALC662_DIGOUT_NID,
18674                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18675                 .channel_mode = alc662_3ST_2ch_modes,
18676                 .unsol_event = alc_sku_unsol_event,
18677                 .setup = alc663_g71v_setup,
18678                 .init_hook = alc_inithook,
18679         },
18680         [ALC663_ASUS_H13] = {
18681                 .mixers = { alc663_m51va_mixer },
18682                 .init_verbs = { alc662_init_verbs,
18683                                 alc662_eapd_init_verbs,
18684                                 alc663_m51va_init_verbs },
18685                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18686                 .dac_nids = alc662_dac_nids,
18687                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18688                 .channel_mode = alc662_3ST_2ch_modes,
18689                 .setup = alc663_m51va_setup,
18690                 .unsol_event = alc_sku_unsol_event,
18691                 .init_hook = alc_inithook,
18692         },
18693         [ALC663_ASUS_G50V] = {
18694                 .mixers = { alc663_g50v_mixer },
18695                 .init_verbs = { alc662_init_verbs,
18696                                 alc662_eapd_init_verbs,
18697                                 alc663_g50v_init_verbs },
18698                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18699                 .dac_nids = alc662_dac_nids,
18700                 .dig_out_nid = ALC662_DIGOUT_NID,
18701                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18702                 .channel_mode = alc662_3ST_6ch_modes,
18703                 .input_mux = &alc663_capture_source,
18704                 .unsol_event = alc_sku_unsol_event,
18705                 .setup = alc663_g50v_setup,
18706                 .init_hook = alc_inithook,
18707         },
18708         [ALC663_ASUS_MODE1] = {
18709                 .mixers = { alc663_m51va_mixer },
18710                 .cap_mixer = alc662_auto_capture_mixer,
18711                 .init_verbs = { alc662_init_verbs,
18712                                 alc662_eapd_init_verbs,
18713                                 alc663_21jd_amic_init_verbs },
18714                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18715                 .hp_nid = 0x03,
18716                 .dac_nids = alc662_dac_nids,
18717                 .dig_out_nid = ALC662_DIGOUT_NID,
18718                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18719                 .channel_mode = alc662_3ST_2ch_modes,
18720                 .unsol_event = alc_sku_unsol_event,
18721                 .setup = alc663_mode1_setup,
18722                 .init_hook = alc_inithook,
18723         },
18724         [ALC662_ASUS_MODE2] = {
18725                 .mixers = { alc662_1bjd_mixer },
18726                 .cap_mixer = alc662_auto_capture_mixer,
18727                 .init_verbs = { alc662_init_verbs,
18728                                 alc662_eapd_init_verbs,
18729                                 alc662_1bjd_amic_init_verbs },
18730                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18731                 .dac_nids = alc662_dac_nids,
18732                 .dig_out_nid = ALC662_DIGOUT_NID,
18733                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18734                 .channel_mode = alc662_3ST_2ch_modes,
18735                 .unsol_event = alc_sku_unsol_event,
18736                 .setup = alc662_mode2_setup,
18737                 .init_hook = alc_inithook,
18738         },
18739         [ALC663_ASUS_MODE3] = {
18740                 .mixers = { alc663_two_hp_m1_mixer },
18741                 .cap_mixer = alc662_auto_capture_mixer,
18742                 .init_verbs = { alc662_init_verbs,
18743                                 alc662_eapd_init_verbs,
18744                                 alc663_two_hp_amic_m1_init_verbs },
18745                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18746                 .hp_nid = 0x03,
18747                 .dac_nids = alc662_dac_nids,
18748                 .dig_out_nid = ALC662_DIGOUT_NID,
18749                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18750                 .channel_mode = alc662_3ST_2ch_modes,
18751                 .unsol_event = alc_sku_unsol_event,
18752                 .setup = alc663_mode3_setup,
18753                 .init_hook = alc_inithook,
18754         },
18755         [ALC663_ASUS_MODE4] = {
18756                 .mixers = { alc663_asus_21jd_clfe_mixer },
18757                 .cap_mixer = alc662_auto_capture_mixer,
18758                 .init_verbs = { alc662_init_verbs,
18759                                 alc662_eapd_init_verbs,
18760                                 alc663_21jd_amic_init_verbs},
18761                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18762                 .hp_nid = 0x03,
18763                 .dac_nids = alc662_dac_nids,
18764                 .dig_out_nid = ALC662_DIGOUT_NID,
18765                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18766                 .channel_mode = alc662_3ST_2ch_modes,
18767                 .unsol_event = alc_sku_unsol_event,
18768                 .setup = alc663_mode4_setup,
18769                 .init_hook = alc_inithook,
18770         },
18771         [ALC663_ASUS_MODE5] = {
18772                 .mixers = { alc663_asus_15jd_clfe_mixer },
18773                 .cap_mixer = alc662_auto_capture_mixer,
18774                 .init_verbs = { alc662_init_verbs,
18775                                 alc662_eapd_init_verbs,
18776                                 alc663_15jd_amic_init_verbs },
18777                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18778                 .hp_nid = 0x03,
18779                 .dac_nids = alc662_dac_nids,
18780                 .dig_out_nid = ALC662_DIGOUT_NID,
18781                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18782                 .channel_mode = alc662_3ST_2ch_modes,
18783                 .unsol_event = alc_sku_unsol_event,
18784                 .setup = alc663_mode5_setup,
18785                 .init_hook = alc_inithook,
18786         },
18787         [ALC663_ASUS_MODE6] = {
18788                 .mixers = { alc663_two_hp_m2_mixer },
18789                 .cap_mixer = alc662_auto_capture_mixer,
18790                 .init_verbs = { alc662_init_verbs,
18791                                 alc662_eapd_init_verbs,
18792                                 alc663_two_hp_amic_m2_init_verbs },
18793                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18794                 .hp_nid = 0x03,
18795                 .dac_nids = alc662_dac_nids,
18796                 .dig_out_nid = ALC662_DIGOUT_NID,
18797                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18798                 .channel_mode = alc662_3ST_2ch_modes,
18799                 .unsol_event = alc_sku_unsol_event,
18800                 .setup = alc663_mode6_setup,
18801                 .init_hook = alc_inithook,
18802         },
18803         [ALC663_ASUS_MODE7] = {
18804                 .mixers = { alc663_mode7_mixer },
18805                 .cap_mixer = alc662_auto_capture_mixer,
18806                 .init_verbs = { alc662_init_verbs,
18807                                 alc662_eapd_init_verbs,
18808                                 alc663_mode7_init_verbs },
18809                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18810                 .hp_nid = 0x03,
18811                 .dac_nids = alc662_dac_nids,
18812                 .dig_out_nid = ALC662_DIGOUT_NID,
18813                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18814                 .channel_mode = alc662_3ST_2ch_modes,
18815                 .unsol_event = alc_sku_unsol_event,
18816                 .setup = alc663_mode7_setup,
18817                 .init_hook = alc_inithook,
18818         },
18819         [ALC663_ASUS_MODE8] = {
18820                 .mixers = { alc663_mode8_mixer },
18821                 .cap_mixer = alc662_auto_capture_mixer,
18822                 .init_verbs = { alc662_init_verbs,
18823                                 alc662_eapd_init_verbs,
18824                                 alc663_mode8_init_verbs },
18825                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18826                 .hp_nid = 0x03,
18827                 .dac_nids = alc662_dac_nids,
18828                 .dig_out_nid = ALC662_DIGOUT_NID,
18829                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18830                 .channel_mode = alc662_3ST_2ch_modes,
18831                 .unsol_event = alc_sku_unsol_event,
18832                 .setup = alc663_mode8_setup,
18833                 .init_hook = alc_inithook,
18834         },
18835         [ALC272_DELL] = {
18836                 .mixers = { alc663_m51va_mixer },
18837                 .cap_mixer = alc272_auto_capture_mixer,
18838                 .init_verbs = { alc662_init_verbs,
18839                                 alc662_eapd_init_verbs,
18840                                 alc272_dell_init_verbs },
18841                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18842                 .dac_nids = alc272_dac_nids,
18843                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18844                 .adc_nids = alc272_adc_nids,
18845                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
18846                 .capsrc_nids = alc272_capsrc_nids,
18847                 .channel_mode = alc662_3ST_2ch_modes,
18848                 .unsol_event = alc_sku_unsol_event,
18849                 .setup = alc663_m51va_setup,
18850                 .init_hook = alc_inithook,
18851         },
18852         [ALC272_DELL_ZM1] = {
18853                 .mixers = { alc663_m51va_mixer },
18854                 .cap_mixer = alc662_auto_capture_mixer,
18855                 .init_verbs = { alc662_init_verbs,
18856                                 alc662_eapd_init_verbs,
18857                                 alc272_dell_zm1_init_verbs },
18858                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18859                 .dac_nids = alc272_dac_nids,
18860                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18861                 .adc_nids = alc662_adc_nids,
18862                 .num_adc_nids = 1,
18863                 .capsrc_nids = alc662_capsrc_nids,
18864                 .channel_mode = alc662_3ST_2ch_modes,
18865                 .unsol_event = alc_sku_unsol_event,
18866                 .setup = alc663_m51va_setup,
18867                 .init_hook = alc_inithook,
18868         },
18869         [ALC272_SAMSUNG_NC10] = {
18870                 .mixers = { alc272_nc10_mixer },
18871                 .init_verbs = { alc662_init_verbs,
18872                                 alc662_eapd_init_verbs,
18873                                 alc663_21jd_amic_init_verbs },
18874                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18875                 .dac_nids = alc272_dac_nids,
18876                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18877                 .channel_mode = alc662_3ST_2ch_modes,
18878                 /*.input_mux = &alc272_nc10_capture_source,*/
18879                 .unsol_event = alc_sku_unsol_event,
18880                 .setup = alc663_mode4_setup,
18881                 .init_hook = alc_inithook,
18882         },
18883 };
18884
18885
18886 /*
18887  * BIOS auto configuration
18888  */
18889
18890 /* convert from MIX nid to DAC */
18891 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
18892 {
18893         hda_nid_t list[5];
18894         int i, num;
18895
18896         num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
18897         for (i = 0; i < num; i++) {
18898                 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
18899                         return list[i];
18900         }
18901         return 0;
18902 }
18903
18904 /* go down to the selector widget before the mixer */
18905 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
18906 {
18907         hda_nid_t srcs[5];
18908         int num = snd_hda_get_connections(codec, pin, srcs,
18909                                           ARRAY_SIZE(srcs));
18910         if (num != 1 ||
18911             get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
18912                 return pin;
18913         return srcs[0];
18914 }
18915
18916 /* get MIX nid connected to the given pin targeted to DAC */
18917 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
18918                                    hda_nid_t dac)
18919 {
18920         hda_nid_t mix[5];
18921         int i, num;
18922
18923         pin = alc_go_down_to_selector(codec, pin);
18924         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
18925         for (i = 0; i < num; i++) {
18926                 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
18927                         return mix[i];
18928         }
18929         return 0;
18930 }
18931
18932 /* select the connection from pin to DAC if needed */
18933 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
18934                                hda_nid_t dac)
18935 {
18936         hda_nid_t mix[5];
18937         int i, num;
18938
18939         pin = alc_go_down_to_selector(codec, pin);
18940         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
18941         if (num < 2)
18942                 return 0;
18943         for (i = 0; i < num; i++) {
18944                 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
18945                         snd_hda_codec_update_cache(codec, pin, 0,
18946                                                    AC_VERB_SET_CONNECT_SEL, i);
18947                         return 0;
18948                 }
18949         }
18950         return 0;
18951 }
18952
18953 /* look for an empty DAC slot */
18954 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
18955 {
18956         struct alc_spec *spec = codec->spec;
18957         hda_nid_t srcs[5];
18958         int i, j, num;
18959
18960         pin = alc_go_down_to_selector(codec, pin);
18961         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
18962         for (i = 0; i < num; i++) {
18963                 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
18964                 if (!nid)
18965                         continue;
18966                 for (j = 0; j < spec->multiout.num_dacs; j++)
18967                         if (spec->multiout.dac_nids[j] == nid)
18968                                 break;
18969                 if (j >= spec->multiout.num_dacs)
18970                         return nid;
18971         }
18972         return 0;
18973 }
18974
18975 /* fill in the dac_nids table from the parsed pin configuration */
18976 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
18977                                      const struct auto_pin_cfg *cfg)
18978 {
18979         struct alc_spec *spec = codec->spec;
18980         int i;
18981         hda_nid_t dac;
18982
18983         spec->multiout.dac_nids = spec->private_dac_nids;
18984         for (i = 0; i < cfg->line_outs; i++) {
18985                 dac = alc_auto_look_for_dac(codec, cfg->line_out_pins[i]);
18986                 if (!dac)
18987                         continue;
18988                 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
18989         }
18990         return 0;
18991 }
18992
18993 static inline int __alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
18994                                        hda_nid_t nid, int idx, unsigned int chs)
18995 {
18996         return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx,
18997                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
18998 }
18999
19000 static inline int __alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
19001                                       hda_nid_t nid, int idx, unsigned int chs)
19002 {
19003         return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
19004                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
19005 }
19006
19007 #define alc662_add_vol_ctl(spec, pfx, nid, chs) \
19008         __alc662_add_vol_ctl(spec, pfx, nid, 0, chs)
19009 #define alc662_add_sw_ctl(spec, pfx, nid, chs) \
19010         __alc662_add_sw_ctl(spec, pfx, nid, 0, chs)
19011 #define alc662_add_stereo_vol(spec, pfx, nid) \
19012         alc662_add_vol_ctl(spec, pfx, nid, 3)
19013 #define alc662_add_stereo_sw(spec, pfx, nid) \
19014         alc662_add_sw_ctl(spec, pfx, nid, 3)
19015
19016 /* add playback controls from the parsed DAC table */
19017 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
19018                                              const struct auto_pin_cfg *cfg)
19019 {
19020         struct alc_spec *spec = codec->spec;
19021         static const char * const chname[4] = {
19022                 "Front", "Surround", NULL /*CLFE*/, "Side"
19023         };
19024         const char *pfx = alc_get_line_out_pfx(spec, true);
19025         hda_nid_t nid, mix, pin;
19026         int i, err, noutputs;
19027
19028         noutputs = cfg->line_outs;
19029         if (spec->multi_ios > 0)
19030                 noutputs += spec->multi_ios;
19031
19032         for (i = 0; i < noutputs; i++) {
19033                 nid = spec->multiout.dac_nids[i];
19034                 if (!nid)
19035                         continue;
19036                 if (i >= cfg->line_outs)
19037                         pin = spec->multi_io[i - 1].pin;
19038                 else
19039                         pin = cfg->line_out_pins[i];
19040                 mix = alc_auto_dac_to_mix(codec, pin, nid);
19041                 if (!mix)
19042                         continue;
19043                 if (!pfx && i == 2) {
19044                         /* Center/LFE */
19045                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
19046                         if (err < 0)
19047                                 return err;
19048                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
19049                         if (err < 0)
19050                                 return err;
19051                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
19052                         if (err < 0)
19053                                 return err;
19054                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
19055                         if (err < 0)
19056                                 return err;
19057                 } else {
19058                         const char *name = pfx;
19059                         int index = i;
19060                         if (!name) {
19061                                 name = chname[i];
19062                                 index = 0;
19063                         }
19064                         err = __alc662_add_vol_ctl(spec, name, nid, index, 3);
19065                         if (err < 0)
19066                                 return err;
19067                         err = __alc662_add_sw_ctl(spec, name, mix, index, 3);
19068                         if (err < 0)
19069                                 return err;
19070                 }
19071         }
19072         return 0;
19073 }
19074
19075 /* add playback controls for speaker and HP outputs */
19076 /* return DAC nid if any new DAC is assigned */
19077 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
19078                                         const char *pfx)
19079 {
19080         struct alc_spec *spec = codec->spec;
19081         hda_nid_t nid, mix;
19082         int err;
19083
19084         if (!pin)
19085                 return 0;
19086         nid = alc_auto_look_for_dac(codec, pin);
19087         if (!nid) {
19088                 /* the corresponding DAC is already occupied */
19089                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
19090                         return 0; /* no way */
19091                 /* create a switch only */
19092                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19093                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
19094         }
19095
19096         mix = alc_auto_dac_to_mix(codec, pin, nid);
19097         if (!mix)
19098                 return 0;
19099         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19100         if (err < 0)
19101                 return err;
19102         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19103         if (err < 0)
19104                 return err;
19105         return nid;
19106 }
19107
19108 /* create playback/capture controls for input pins */
19109 #define alc662_auto_create_input_ctls \
19110         alc882_auto_create_input_ctls
19111
19112 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
19113                                               hda_nid_t nid, int pin_type,
19114                                               hda_nid_t dac)
19115 {
19116         int i, num;
19117         hda_nid_t srcs[HDA_MAX_CONNECTIONS];
19118
19119         alc_set_pin_output(codec, nid, pin_type);
19120         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
19121         for (i = 0; i < num; i++) {
19122                 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
19123                         continue;
19124                 /* need the manual connection? */
19125                 if (num > 1)
19126                         snd_hda_codec_write(codec, nid, 0,
19127                                             AC_VERB_SET_CONNECT_SEL, i);
19128                 /* unmute mixer widget inputs */
19129                 snd_hda_codec_write(codec, srcs[i], 0,
19130                                     AC_VERB_SET_AMP_GAIN_MUTE,
19131                                     AMP_IN_UNMUTE(0));
19132                 snd_hda_codec_write(codec, srcs[i], 0,
19133                                     AC_VERB_SET_AMP_GAIN_MUTE,
19134                                     AMP_IN_UNMUTE(1));
19135                 return;
19136         }
19137 }
19138
19139 static void alc662_auto_init_multi_out(struct hda_codec *codec)
19140 {
19141         struct alc_spec *spec = codec->spec;
19142         int pin_type = get_pin_type(spec->autocfg.line_out_type);
19143         int i;
19144
19145         for (i = 0; i <= HDA_SIDE; i++) {
19146                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
19147                 if (nid)
19148                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
19149                                         spec->multiout.dac_nids[i]);
19150         }
19151 }
19152
19153 static void alc662_auto_init_hp_out(struct hda_codec *codec)
19154 {
19155         struct alc_spec *spec = codec->spec;
19156         hda_nid_t pin;
19157
19158         pin = spec->autocfg.hp_pins[0];
19159         if (pin)
19160                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
19161                                                   spec->multiout.hp_nid);
19162         pin = spec->autocfg.speaker_pins[0];
19163         if (pin)
19164                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
19165                                         spec->multiout.extra_out_nid[0]);
19166 }
19167
19168 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
19169
19170 static void alc662_auto_init_analog_input(struct hda_codec *codec)
19171 {
19172         struct alc_spec *spec = codec->spec;
19173         struct auto_pin_cfg *cfg = &spec->autocfg;
19174         int i;
19175
19176         for (i = 0; i < cfg->num_inputs; i++) {
19177                 hda_nid_t nid = cfg->inputs[i].pin;
19178                 if (alc_is_input_pin(codec, nid)) {
19179                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
19180                         if (nid != ALC662_PIN_CD_NID &&
19181                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
19182                                 snd_hda_codec_write(codec, nid, 0,
19183                                                     AC_VERB_SET_AMP_GAIN_MUTE,
19184                                                     AMP_OUT_MUTE);
19185                 }
19186         }
19187 }
19188
19189 #define alc662_auto_init_input_src      alc882_auto_init_input_src
19190
19191 /*
19192  * multi-io helper
19193  */
19194 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
19195                                    unsigned int location)
19196 {
19197         struct alc_spec *spec = codec->spec;
19198         struct auto_pin_cfg *cfg = &spec->autocfg;
19199         int type, i, num_pins = 0;
19200
19201         for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
19202                 for (i = 0; i < cfg->num_inputs; i++) {
19203                         hda_nid_t nid = cfg->inputs[i].pin;
19204                         hda_nid_t dac;
19205                         unsigned int defcfg, caps;
19206                         if (cfg->inputs[i].type != type)
19207                                 continue;
19208                         defcfg = snd_hda_codec_get_pincfg(codec, nid);
19209                         if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
19210                                 continue;
19211                         if (location && get_defcfg_location(defcfg) != location)
19212                                 continue;
19213                         caps = snd_hda_query_pin_caps(codec, nid);
19214                         if (!(caps & AC_PINCAP_OUT))
19215                                 continue;
19216                         dac = alc_auto_look_for_dac(codec, nid);
19217                         if (!dac)
19218                                 continue;
19219                         spec->multi_io[num_pins].pin = nid;
19220                         spec->multi_io[num_pins].dac = dac;
19221                         num_pins++;
19222                         spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
19223                 }
19224         }
19225         spec->multiout.num_dacs = 1;
19226         if (num_pins < 2)
19227                 return 0;
19228         return num_pins;
19229 }
19230
19231 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
19232                                  struct snd_ctl_elem_info *uinfo)
19233 {
19234         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
19235         struct alc_spec *spec = codec->spec;
19236
19237         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
19238         uinfo->count = 1;
19239         uinfo->value.enumerated.items = spec->multi_ios + 1;
19240         if (uinfo->value.enumerated.item > spec->multi_ios)
19241                 uinfo->value.enumerated.item = spec->multi_ios;
19242         sprintf(uinfo->value.enumerated.name, "%dch",
19243                 (uinfo->value.enumerated.item + 1) * 2);
19244         return 0;
19245 }
19246
19247 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol,
19248                                 struct snd_ctl_elem_value *ucontrol)
19249 {
19250         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
19251         struct alc_spec *spec = codec->spec;
19252         ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
19253         return 0;
19254 }
19255
19256 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
19257 {
19258         struct alc_spec *spec = codec->spec;
19259         hda_nid_t nid = spec->multi_io[idx].pin;
19260
19261         if (!spec->multi_io[idx].ctl_in)
19262                 spec->multi_io[idx].ctl_in =
19263                         snd_hda_codec_read(codec, nid, 0,
19264                                            AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
19265         if (output) {
19266                 snd_hda_codec_update_cache(codec, nid, 0,
19267                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
19268                                            PIN_OUT);
19269                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
19270                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
19271                                                  HDA_AMP_MUTE, 0);
19272                 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
19273         } else {
19274                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
19275                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
19276                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
19277                 snd_hda_codec_update_cache(codec, nid, 0,
19278                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
19279                                            spec->multi_io[idx].ctl_in);
19280         }
19281         return 0;
19282 }
19283
19284 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
19285                                 struct snd_ctl_elem_value *ucontrol)
19286 {
19287         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
19288         struct alc_spec *spec = codec->spec;
19289         int i, ch;
19290
19291         ch = ucontrol->value.enumerated.item[0];
19292         if (ch < 0 || ch > spec->multi_ios)
19293                 return -EINVAL;
19294         if (ch == (spec->ext_channel_count - 1) / 2)
19295                 return 0;
19296         spec->ext_channel_count = (ch + 1) * 2;
19297         for (i = 0; i < spec->multi_ios; i++)
19298                 alc_set_multi_io(codec, i, i < ch);
19299         spec->multiout.max_channels = spec->ext_channel_count;
19300         return 1;
19301 }
19302
19303 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
19304         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
19305         .name = "Channel Mode",
19306         .info = alc_auto_ch_mode_info,
19307         .get = alc_auto_ch_mode_get,
19308         .put = alc_auto_ch_mode_put,
19309 };
19310
19311 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec)
19312 {
19313         struct alc_spec *spec = codec->spec;
19314         struct auto_pin_cfg *cfg = &spec->autocfg;
19315         unsigned int location, defcfg;
19316         int num_pins;
19317
19318         if (cfg->line_outs != 1 ||
19319             cfg->line_out_type != AUTO_PIN_LINE_OUT)
19320                 return 0;
19321
19322         defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
19323         location = get_defcfg_location(defcfg);
19324
19325         num_pins = alc_auto_fill_multi_ios(codec, location);
19326         if (num_pins > 0) {
19327                 struct snd_kcontrol_new *knew;
19328
19329                 knew = alc_kcontrol_new(spec);
19330                 if (!knew)
19331                         return -ENOMEM;
19332                 *knew = alc_auto_channel_mode_enum;
19333                 knew->name = kstrdup("Channel Mode", GFP_KERNEL);
19334                 if (!knew->name)
19335                         return -ENOMEM;
19336
19337                 spec->multi_ios = num_pins;
19338                 spec->ext_channel_count = 2;
19339                 spec->multiout.num_dacs = num_pins + 1;
19340         }
19341         return 0;
19342 }
19343
19344 static int alc662_parse_auto_config(struct hda_codec *codec)
19345 {
19346         struct alc_spec *spec = codec->spec;
19347         int err;
19348         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
19349
19350         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19351                                            alc662_ignore);
19352         if (err < 0)
19353                 return err;
19354         if (!spec->autocfg.line_outs)
19355                 return 0; /* can't find valid BIOS pin config */
19356
19357         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
19358         if (err < 0)
19359                 return err;
19360         err = alc_auto_add_multi_channel_mode(codec);
19361         if (err < 0)
19362                 return err;
19363         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
19364         if (err < 0)
19365                 return err;
19366         err = alc662_auto_create_extra_out(codec,
19367                                            spec->autocfg.speaker_pins[0],
19368                                            "Speaker");
19369         if (err < 0)
19370                 return err;
19371         if (err)
19372                 spec->multiout.extra_out_nid[0] = err;
19373         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
19374                                            "Headphone");
19375         if (err < 0)
19376                 return err;
19377         if (err)
19378                 spec->multiout.hp_nid = err;
19379         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
19380         if (err < 0)
19381                 return err;
19382
19383         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
19384
19385         alc_auto_parse_digital(codec);
19386
19387         if (spec->kctls.list)
19388                 add_mixer(spec, spec->kctls.list);
19389
19390         spec->num_mux_defs = 1;
19391         spec->input_mux = &spec->private_imux[0];
19392
19393         err = alc_auto_add_mic_boost(codec);
19394         if (err < 0)
19395                 return err;
19396
19397         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19398             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19399             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
19400         else
19401             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
19402
19403         return 1;
19404 }
19405
19406 /* additional initialization for auto-configuration model */
19407 static void alc662_auto_init(struct hda_codec *codec)
19408 {
19409         struct alc_spec *spec = codec->spec;
19410         alc662_auto_init_multi_out(codec);
19411         alc662_auto_init_hp_out(codec);
19412         alc662_auto_init_analog_input(codec);
19413         alc662_auto_init_input_src(codec);
19414         alc_auto_init_digital(codec);
19415         if (spec->unsol_event)
19416                 alc_inithook(codec);
19417 }
19418
19419 static void alc272_fixup_mario(struct hda_codec *codec,
19420                                const struct alc_fixup *fix, int action)
19421 {
19422         if (action != ALC_FIXUP_ACT_PROBE)
19423                 return;
19424         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
19425                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
19426                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
19427                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
19428                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
19429                 printk(KERN_WARNING
19430                        "hda_codec: failed to override amp caps for NID 0x2\n");
19431 }
19432
19433 enum {
19434         ALC662_FIXUP_ASPIRE,
19435         ALC662_FIXUP_IDEAPAD,
19436         ALC272_FIXUP_MARIO,
19437         ALC662_FIXUP_CZC_P10T,
19438         ALC662_FIXUP_SKU_IGNORE,
19439 };
19440
19441 static const struct alc_fixup alc662_fixups[] = {
19442         [ALC662_FIXUP_ASPIRE] = {
19443                 .type = ALC_FIXUP_PINS,
19444                 .v.pins = (const struct alc_pincfg[]) {
19445                         { 0x15, 0x99130112 }, /* subwoofer */
19446                         { }
19447                 }
19448         },
19449         [ALC662_FIXUP_IDEAPAD] = {
19450                 .type = ALC_FIXUP_PINS,
19451                 .v.pins = (const struct alc_pincfg[]) {
19452                         { 0x17, 0x99130112 }, /* subwoofer */
19453                         { }
19454                 }
19455         },
19456         [ALC272_FIXUP_MARIO] = {
19457                 .type = ALC_FIXUP_FUNC,
19458                 .v.func = alc272_fixup_mario,
19459         },
19460         [ALC662_FIXUP_CZC_P10T] = {
19461                 .type = ALC_FIXUP_VERBS,
19462                 .v.verbs = (const struct hda_verb[]) {
19463                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
19464                         {}
19465                 }
19466         },
19467         [ALC662_FIXUP_SKU_IGNORE] = {
19468                 .type = ALC_FIXUP_SKU,
19469                 .v.sku = ALC_FIXUP_SKU_IGNORE,
19470         },
19471 };
19472
19473 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
19474         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
19475         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
19476         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
19477         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
19478         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
19479         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
19480         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
19481         {}
19482 };
19483
19484 static const struct alc_model_fixup alc662_fixup_models[] = {
19485         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
19486         {}
19487 };
19488
19489
19490 static int patch_alc662(struct hda_codec *codec)
19491 {
19492         struct alc_spec *spec;
19493         int err, board_config;
19494         int coef;
19495
19496         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19497         if (!spec)
19498                 return -ENOMEM;
19499
19500         codec->spec = spec;
19501
19502         alc_auto_parse_customize_define(codec);
19503
19504         alc_fix_pll_init(codec, 0x20, 0x04, 15);
19505
19506         coef = alc_read_coef_idx(codec, 0);
19507         if (coef == 0x8020 || coef == 0x8011)
19508                 alc_codec_rename(codec, "ALC661");
19509         else if (coef & (1 << 14) &&
19510                 codec->bus->pci->subsystem_vendor == 0x1025 &&
19511                 spec->cdefine.platform_type == 1)
19512                 alc_codec_rename(codec, "ALC272X");
19513         else if (coef == 0x4011)
19514                 alc_codec_rename(codec, "ALC656");
19515
19516         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
19517                                                   alc662_models,
19518                                                   alc662_cfg_tbl);
19519         if (board_config < 0) {
19520                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19521                        codec->chip_name);
19522                 board_config = ALC662_AUTO;
19523         }
19524
19525         if (board_config == ALC662_AUTO) {
19526                 alc_pick_fixup(codec, alc662_fixup_models,
19527                                alc662_fixup_tbl, alc662_fixups);
19528                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
19529                 /* automatic parse from the BIOS config */
19530                 err = alc662_parse_auto_config(codec);
19531                 if (err < 0) {
19532                         alc_free(codec);
19533                         return err;
19534                 } else if (!err) {
19535                         printk(KERN_INFO
19536                                "hda_codec: Cannot set up configuration "
19537                                "from BIOS.  Using base mode...\n");
19538                         board_config = ALC662_3ST_2ch_DIG;
19539                 }
19540         }
19541
19542         if (has_cdefine_beep(codec)) {
19543                 err = snd_hda_attach_beep_device(codec, 0x1);
19544                 if (err < 0) {
19545                         alc_free(codec);
19546                         return err;
19547                 }
19548         }
19549
19550         if (board_config != ALC662_AUTO)
19551                 setup_preset(codec, &alc662_presets[board_config]);
19552
19553         spec->stream_analog_playback = &alc662_pcm_analog_playback;
19554         spec->stream_analog_capture = &alc662_pcm_analog_capture;
19555
19556         spec->stream_digital_playback = &alc662_pcm_digital_playback;
19557         spec->stream_digital_capture = &alc662_pcm_digital_capture;
19558
19559         if (!spec->adc_nids) {
19560                 spec->adc_nids = alc662_adc_nids;
19561                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
19562         }
19563         if (!spec->capsrc_nids)
19564                 spec->capsrc_nids = alc662_capsrc_nids;
19565
19566         if (!spec->cap_mixer)
19567                 set_capture_mixer(codec);
19568
19569         if (has_cdefine_beep(codec)) {
19570                 switch (codec->vendor_id) {
19571                 case 0x10ec0662:
19572                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
19573                         break;
19574                 case 0x10ec0272:
19575                 case 0x10ec0663:
19576                 case 0x10ec0665:
19577                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
19578                         break;
19579                 case 0x10ec0273:
19580                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
19581                         break;
19582                 }
19583         }
19584         spec->vmaster_nid = 0x02;
19585
19586         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
19587
19588         codec->patch_ops = alc_patch_ops;
19589         if (board_config == ALC662_AUTO)
19590                 spec->init_hook = alc662_auto_init;
19591         spec->shutup = alc_eapd_shutup;
19592
19593         alc_init_jacks(codec);
19594
19595 #ifdef CONFIG_SND_HDA_POWER_SAVE
19596         if (!spec->loopback.amplist)
19597                 spec->loopback.amplist = alc662_loopbacks;
19598 #endif
19599
19600         return 0;
19601 }
19602
19603 static int patch_alc888(struct hda_codec *codec)
19604 {
19605         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
19606                 kfree(codec->chip_name);
19607                 if (codec->vendor_id == 0x10ec0887)
19608                         codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL);
19609                 else
19610                         codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
19611                 if (!codec->chip_name) {
19612                         alc_free(codec);
19613                         return -ENOMEM;
19614                 }
19615                 return patch_alc662(codec);
19616         }
19617         return patch_alc882(codec);
19618 }
19619
19620 static int patch_alc899(struct hda_codec *codec)
19621 {
19622         if ((alc_read_coef_idx(codec, 0) & 0x2000) != 0x2000) {
19623                 kfree(codec->chip_name);
19624                 codec->chip_name = kstrdup("ALC898", GFP_KERNEL);
19625         }
19626         return patch_alc882(codec);
19627 }
19628
19629 /*
19630  * ALC680 support
19631  */
19632 #define ALC680_DIGIN_NID        ALC880_DIGIN_NID
19633 #define ALC680_DIGOUT_NID       ALC880_DIGOUT_NID
19634 #define alc680_modes            alc260_modes
19635
19636 static const hda_nid_t alc680_dac_nids[3] = {
19637         /* Lout1, Lout2, hp */
19638         0x02, 0x03, 0x04
19639 };
19640
19641 static const hda_nid_t alc680_adc_nids[3] = {
19642         /* ADC0-2 */
19643         /* DMIC, MIC, Line-in*/
19644         0x07, 0x08, 0x09
19645 };
19646
19647 /*
19648  * Analog capture ADC cgange
19649  */
19650 static void alc680_rec_autoswitch(struct hda_codec *codec)
19651 {
19652         struct alc_spec *spec = codec->spec;
19653         struct auto_pin_cfg *cfg = &spec->autocfg;
19654         int pin_found = 0;
19655         int type_found = AUTO_PIN_LAST;
19656         hda_nid_t nid;
19657         int i;
19658
19659         for (i = 0; i < cfg->num_inputs; i++) {
19660                 nid = cfg->inputs[i].pin;
19661                 if (!is_jack_detectable(codec, nid))
19662                         continue;
19663                 if (snd_hda_jack_detect(codec, nid)) {
19664                         if (cfg->inputs[i].type < type_found) {
19665                                 type_found = cfg->inputs[i].type;
19666                                 pin_found = nid;
19667                         }
19668                 }
19669         }
19670
19671         nid = 0x07;
19672         if (pin_found)
19673                 snd_hda_get_connections(codec, pin_found, &nid, 1);
19674
19675         if (nid != spec->cur_adc)
19676                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
19677         spec->cur_adc = nid;
19678         snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0,
19679                                    spec->cur_adc_format);
19680 }
19681
19682 static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
19683                                       struct hda_codec *codec,
19684                                       unsigned int stream_tag,
19685                                       unsigned int format,
19686                                       struct snd_pcm_substream *substream)
19687 {
19688         struct alc_spec *spec = codec->spec;
19689
19690         spec->cur_adc = 0x07;
19691         spec->cur_adc_stream_tag = stream_tag;
19692         spec->cur_adc_format = format;
19693
19694         alc680_rec_autoswitch(codec);
19695         return 0;
19696 }
19697
19698 static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
19699                                       struct hda_codec *codec,
19700                                       struct snd_pcm_substream *substream)
19701 {
19702         snd_hda_codec_cleanup_stream(codec, 0x07);
19703         snd_hda_codec_cleanup_stream(codec, 0x08);
19704         snd_hda_codec_cleanup_stream(codec, 0x09);
19705         return 0;
19706 }
19707
19708 static const struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
19709         .substreams = 1, /* can be overridden */
19710         .channels_min = 2,
19711         .channels_max = 2,
19712         /* NID is set in alc_build_pcms */
19713         .ops = {
19714                 .prepare = alc680_capture_pcm_prepare,
19715                 .cleanup = alc680_capture_pcm_cleanup
19716         },
19717 };
19718
19719 static const struct snd_kcontrol_new alc680_base_mixer[] = {
19720         /* output mixer control */
19721         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
19722         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
19723         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
19724         HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
19725         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x12, 0, HDA_INPUT),
19726         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
19727         HDA_CODEC_VOLUME("Line In Boost Volume", 0x19, 0, HDA_INPUT),
19728         { }
19729 };
19730
19731 static const struct hda_bind_ctls alc680_bind_cap_vol = {
19732         .ops = &snd_hda_bind_vol,
19733         .values = {
19734                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19735                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19736                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19737                 0
19738         },
19739 };
19740
19741 static const struct hda_bind_ctls alc680_bind_cap_switch = {
19742         .ops = &snd_hda_bind_sw,
19743         .values = {
19744                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19745                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19746                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19747                 0
19748         },
19749 };
19750
19751 static const struct snd_kcontrol_new alc680_master_capture_mixer[] = {
19752         HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
19753         HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
19754         { } /* end */
19755 };
19756
19757 /*
19758  * generic initialization of ADC, input mixers and output mixers
19759  */
19760 static const struct hda_verb alc680_init_verbs[] = {
19761         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19762         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19763         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19764
19765         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19766         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19767         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19768         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
19769         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
19770         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19771
19772         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19773         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19774         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19775         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19776         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19777
19778         {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT   | AC_USRSP_EN},
19779         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19780         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19781
19782         { }
19783 };
19784
19785 /* toggle speaker-output according to the hp-jack state */
19786 static void alc680_base_setup(struct hda_codec *codec)
19787 {
19788         struct alc_spec *spec = codec->spec;
19789
19790         spec->autocfg.hp_pins[0] = 0x16;
19791         spec->autocfg.speaker_pins[0] = 0x14;
19792         spec->autocfg.speaker_pins[1] = 0x15;
19793         spec->autocfg.num_inputs = 2;
19794         spec->autocfg.inputs[0].pin = 0x18;
19795         spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
19796         spec->autocfg.inputs[1].pin = 0x19;
19797         spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
19798         spec->automute = 1;
19799         spec->automute_mode = ALC_AUTOMUTE_AMP;
19800 }
19801
19802 static void alc680_unsol_event(struct hda_codec *codec,
19803                                            unsigned int res)
19804 {
19805         if ((res >> 26) == ALC880_HP_EVENT)
19806                 alc_hp_automute(codec);
19807         if ((res >> 26) == ALC880_MIC_EVENT)
19808                 alc680_rec_autoswitch(codec);
19809 }
19810
19811 static void alc680_inithook(struct hda_codec *codec)
19812 {
19813         alc_hp_automute(codec);
19814         alc680_rec_autoswitch(codec);
19815 }
19816
19817 /* create input playback/capture controls for the given pin */
19818 static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
19819                                     const char *ctlname, int idx)
19820 {
19821         hda_nid_t dac;
19822         int err;
19823
19824         switch (nid) {
19825         case 0x14:
19826                 dac = 0x02;
19827                 break;
19828         case 0x15:
19829                 dac = 0x03;
19830                 break;
19831         case 0x16:
19832                 dac = 0x04;
19833                 break;
19834         default:
19835                 return 0;
19836         }
19837         if (spec->multiout.dac_nids[0] != dac &&
19838             spec->multiout.dac_nids[1] != dac) {
19839                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
19840                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
19841                                                       HDA_OUTPUT));
19842                 if (err < 0)
19843                         return err;
19844
19845                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
19846                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
19847
19848                 if (err < 0)
19849                         return err;
19850                 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
19851         }
19852
19853         return 0;
19854 }
19855
19856 /* add playback controls from the parsed DAC table */
19857 static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
19858                                              const struct auto_pin_cfg *cfg)
19859 {
19860         hda_nid_t nid;
19861         int err;
19862
19863         spec->multiout.dac_nids = spec->private_dac_nids;
19864
19865         nid = cfg->line_out_pins[0];
19866         if (nid) {
19867                 const char *name;
19868                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19869                         name = "Speaker";
19870                 else
19871                         name = "Front";
19872                 err = alc680_new_analog_output(spec, nid, name, 0);
19873                 if (err < 0)
19874                         return err;
19875         }
19876
19877         nid = cfg->speaker_pins[0];
19878         if (nid) {
19879                 err = alc680_new_analog_output(spec, nid, "Speaker", 0);
19880                 if (err < 0)
19881                         return err;
19882         }
19883         nid = cfg->hp_pins[0];
19884         if (nid) {
19885                 err = alc680_new_analog_output(spec, nid, "Headphone", 0);
19886                 if (err < 0)
19887                         return err;
19888         }
19889
19890         return 0;
19891 }
19892
19893 static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
19894                                               hda_nid_t nid, int pin_type)
19895 {
19896         alc_set_pin_output(codec, nid, pin_type);
19897 }
19898
19899 static void alc680_auto_init_multi_out(struct hda_codec *codec)
19900 {
19901         struct alc_spec *spec = codec->spec;
19902         hda_nid_t nid = spec->autocfg.line_out_pins[0];
19903         if (nid) {
19904                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
19905                 alc680_auto_set_output_and_unmute(codec, nid, pin_type);
19906         }
19907 }
19908
19909 static void alc680_auto_init_hp_out(struct hda_codec *codec)
19910 {
19911         struct alc_spec *spec = codec->spec;
19912         hda_nid_t pin;
19913
19914         pin = spec->autocfg.hp_pins[0];
19915         if (pin)
19916                 alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
19917         pin = spec->autocfg.speaker_pins[0];
19918         if (pin)
19919                 alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
19920 }
19921
19922 /* pcm configuration: identical with ALC880 */
19923 #define alc680_pcm_analog_playback      alc880_pcm_analog_playback
19924 #define alc680_pcm_analog_capture       alc880_pcm_analog_capture
19925 #define alc680_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
19926 #define alc680_pcm_digital_playback     alc880_pcm_digital_playback
19927 #define alc680_pcm_digital_capture      alc880_pcm_digital_capture
19928
19929 /*
19930  * BIOS auto configuration
19931  */
19932 static int alc680_parse_auto_config(struct hda_codec *codec)
19933 {
19934         struct alc_spec *spec = codec->spec;
19935         int err;
19936         static const hda_nid_t alc680_ignore[] = { 0 };
19937
19938         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19939                                            alc680_ignore);
19940         if (err < 0)
19941                 return err;
19942
19943         if (!spec->autocfg.line_outs) {
19944                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
19945                         spec->multiout.max_channels = 2;
19946                         spec->no_analog = 1;
19947                         goto dig_only;
19948                 }
19949                 return 0; /* can't find valid BIOS pin config */
19950         }
19951         err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
19952         if (err < 0)
19953                 return err;
19954
19955         spec->multiout.max_channels = 2;
19956
19957  dig_only:
19958         /* digital only support output */
19959         alc_auto_parse_digital(codec);
19960         if (spec->kctls.list)
19961                 add_mixer(spec, spec->kctls.list);
19962
19963         add_verb(spec, alc680_init_verbs);
19964
19965         err = alc_auto_add_mic_boost(codec);
19966         if (err < 0)
19967                 return err;
19968
19969         return 1;
19970 }
19971
19972 #define alc680_auto_init_analog_input   alc882_auto_init_analog_input
19973
19974 /* init callback for auto-configuration model -- overriding the default init */
19975 static void alc680_auto_init(struct hda_codec *codec)
19976 {
19977         struct alc_spec *spec = codec->spec;
19978         alc680_auto_init_multi_out(codec);
19979         alc680_auto_init_hp_out(codec);
19980         alc680_auto_init_analog_input(codec);
19981         alc_auto_init_digital(codec);
19982         if (spec->unsol_event)
19983                 alc_inithook(codec);
19984 }
19985
19986 /*
19987  * configuration and preset
19988  */
19989 static const char * const alc680_models[ALC680_MODEL_LAST] = {
19990         [ALC680_BASE]           = "base",
19991         [ALC680_AUTO]           = "auto",
19992 };
19993
19994 static const struct snd_pci_quirk alc680_cfg_tbl[] = {
19995         SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
19996         {}
19997 };
19998
19999 static const struct alc_config_preset alc680_presets[] = {
20000         [ALC680_BASE] = {
20001                 .mixers = { alc680_base_mixer },
20002                 .cap_mixer =  alc680_master_capture_mixer,
20003                 .init_verbs = { alc680_init_verbs },
20004                 .num_dacs = ARRAY_SIZE(alc680_dac_nids),
20005                 .dac_nids = alc680_dac_nids,
20006                 .dig_out_nid = ALC680_DIGOUT_NID,
20007                 .num_channel_mode = ARRAY_SIZE(alc680_modes),
20008                 .channel_mode = alc680_modes,
20009                 .unsol_event = alc680_unsol_event,
20010                 .setup = alc680_base_setup,
20011                 .init_hook = alc680_inithook,
20012
20013         },
20014 };
20015
20016 static int patch_alc680(struct hda_codec *codec)
20017 {
20018         struct alc_spec *spec;
20019         int board_config;
20020         int err;
20021
20022         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
20023         if (spec == NULL)
20024                 return -ENOMEM;
20025
20026         codec->spec = spec;
20027
20028         board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
20029                                                   alc680_models,
20030                                                   alc680_cfg_tbl);
20031
20032         if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
20033                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
20034                        codec->chip_name);
20035                 board_config = ALC680_AUTO;
20036         }
20037
20038         if (board_config == ALC680_AUTO) {
20039                 /* automatic parse from the BIOS config */
20040                 err = alc680_parse_auto_config(codec);
20041                 if (err < 0) {
20042                         alc_free(codec);
20043                         return err;
20044                 } else if (!err) {
20045                         printk(KERN_INFO
20046                                "hda_codec: Cannot set up configuration "
20047                                "from BIOS.  Using base mode...\n");
20048                         board_config = ALC680_BASE;
20049                 }
20050         }
20051
20052         if (board_config != ALC680_AUTO)
20053                 setup_preset(codec, &alc680_presets[board_config]);
20054
20055         spec->stream_analog_playback = &alc680_pcm_analog_playback;
20056         spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
20057         spec->stream_digital_playback = &alc680_pcm_digital_playback;
20058         spec->stream_digital_capture = &alc680_pcm_digital_capture;
20059
20060         if (!spec->adc_nids) {
20061                 spec->adc_nids = alc680_adc_nids;
20062                 spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
20063         }
20064
20065         if (!spec->cap_mixer)
20066                 set_capture_mixer(codec);
20067
20068         spec->vmaster_nid = 0x02;
20069
20070         codec->patch_ops = alc_patch_ops;
20071         if (board_config == ALC680_AUTO)
20072                 spec->init_hook = alc680_auto_init;
20073
20074         return 0;
20075 }
20076
20077 /*
20078  * patch entries
20079  */
20080 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
20081         { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
20082         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
20083         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
20084         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
20085         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
20086         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
20087         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
20088         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
20089         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
20090         { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
20091         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
20092           .patch = patch_alc861 },
20093         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
20094         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
20095         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
20096         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
20097           .patch = patch_alc882 },
20098         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
20099           .patch = patch_alc662 },
20100         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
20101         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
20102         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
20103         { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
20104         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
20105         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
20106         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
20107         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
20108           .patch = patch_alc882 },
20109         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
20110           .patch = patch_alc882 },
20111         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
20112         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 },
20113         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
20114           .patch = patch_alc882 },
20115         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
20116         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
20117         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
20118         { .id = 0x10ec0899, .name = "ALC899", .patch = patch_alc899 },
20119         {} /* terminator */
20120 };
20121
20122 MODULE_ALIAS("snd-hda-codec-id:10ec*");
20123
20124 MODULE_LICENSE("GPL");
20125 MODULE_DESCRIPTION("Realtek HD-audio codec");
20126
20127 static struct hda_codec_preset_list realtek_list = {
20128         .preset = snd_hda_preset_realtek,
20129         .owner = THIS_MODULE,
20130 };
20131
20132 static int __init patch_realtek_init(void)
20133 {
20134         return snd_hda_add_codec_preset(&realtek_list);
20135 }
20136
20137 static void __exit patch_realtek_exit(void)
20138 {
20139         snd_hda_delete_codec_preset(&realtek_list);
20140 }
20141
20142 module_init(patch_realtek_init)
20143 module_exit(patch_realtek_exit)