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 struct alc_jack {
 286         hda_nid_t nid;
 287         int type;
 288         struct snd_jack *jack;
 289 };
 290
 291 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 292
 293 struct alc_customize_define {
 294         unsigned int  sku_cfg;
 295         unsigned char port_connectivity;
 296         unsigned char check_sum;
 297         unsigned char customization;
 298         unsigned char external_amp;
 299         unsigned int  enable_pcbeep:1;
 300         unsigned int  platform_type:1;
 301         unsigned int  swap:1;
 302         unsigned int  override:1;
 303         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
 304 };
 305
 306 struct alc_fixup;
 307
 308 struct alc_spec {
 309         /* codec parameterization */
 310         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 311         unsigned int num_mixers;
 312         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 313         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 314
 315         const struct hda_verb *init_verbs[10];  /* initialization verbs
 316                                                  * don't forget NULL
 317                                                  * termination!
 318                                                  */
 319         unsigned int num_init_verbs;
 320
 321         char stream_name_analog[32];    /* analog PCM stream */
 322         struct hda_pcm_stream *stream_analog_playback;
 323         struct hda_pcm_stream *stream_analog_capture;
 324         struct hda_pcm_stream *stream_analog_alt_playback;
 325         struct hda_pcm_stream *stream_analog_alt_capture;
 326
 327         char stream_name_digital[32];   /* digital PCM stream */
 328         struct hda_pcm_stream *stream_digital_playback;
 329         struct hda_pcm_stream *stream_digital_capture;
 330
 331         /* playback */
 332         struct hda_multi_out multiout;  /* playback set-up
 333                                          * max_channels, dacs must be set
 334                                          * dig_out_nid and hp_nid are optional
 335                                          */
 336         hda_nid_t alt_dac_nid;
 337         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 338         int dig_out_type;
 339
 340         /* capture */
 341         unsigned int num_adc_nids;
 342         hda_nid_t *adc_nids;
 343         hda_nid_t *capsrc_nids;
 344         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 345
 346         /* capture setup for dynamic dual-adc switch */
 347         unsigned int cur_adc_idx;
 348         hda_nid_t cur_adc;
 349         unsigned int cur_adc_stream_tag;
 350         unsigned int cur_adc_format;
 351
 352         /* capture source */
 353         unsigned int num_mux_defs;
 354         const struct hda_input_mux *input_mux;
 355         unsigned int cur_mux[3];
 356         struct alc_mic_route ext_mic;
 357         struct alc_mic_route int_mic;
 358
 359         /* channel model */
 360         const struct hda_channel_mode *channel_mode;
 361         int num_channel_mode;
 362         int need_dac_fix;
 363         int const_channel_count;
 364         int ext_channel_count;
 365
 366         /* PCM information */
 367         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 368
 369         /* jack detection */
 370         struct snd_array jacks;
 371
 372         /* dynamic controls, init_verbs and input_mux */
 373         struct auto_pin_cfg autocfg;
 374         struct alc_customize_define cdefine;
 375         struct snd_array kctls;
 376         struct hda_input_mux private_imux[3];
 377         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 378         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 379         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 380
 381         /* hooks */
 382         void (*init_hook)(struct hda_codec *codec);
 383         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 384 #ifdef CONFIG_SND_HDA_POWER_SAVE
 385         void (*power_hook)(struct hda_codec *codec);
 386 #endif
 387
 388         /* for pin sensing */
 389         unsigned int sense_updated: 1;
 390         unsigned int jack_present: 1;
 391         unsigned int master_sw: 1;
 392         unsigned int auto_mic:1;
 393
 394         /* other flags */
 395         unsigned int no_analog :1; /* digital I/O only */
 396         unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */
 397         int init_amp;
 398         int codec_variant;      /* flag for other variants */
 399
 400         /* for virtual master */
 401         hda_nid_t vmaster_nid;
 402 #ifdef CONFIG_SND_HDA_POWER_SAVE
 403         struct hda_loopback_check loopback;
 404 #endif
 405
 406         /* for PLL fix */
 407         hda_nid_t pll_nid;
 408         unsigned int pll_coef_idx, pll_coef_bit;
 409
 410         /* fix-up list */
 411         int fixup_id;
 412         const struct alc_fixup *fixup_list;
 413         const char *fixup_name;
 414 };
 415
 416 /*
 417  * configuration template - to be copied to the spec instance
 418  */
 419 struct alc_config_preset {
 420         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 421                                              * with spec
 422                                              */
 423         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 424         const struct hda_verb *init_verbs[5];
 425         unsigned int num_dacs;
 426         hda_nid_t *dac_nids;
 427         hda_nid_t dig_out_nid;          /* optional */
 428         hda_nid_t hp_nid;               /* optional */
 429         hda_nid_t *slave_dig_outs;
 430         unsigned int num_adc_nids;
 431         hda_nid_t *adc_nids;
 432         hda_nid_t *capsrc_nids;
 433         hda_nid_t dig_in_nid;
 434         unsigned int num_channel_mode;
 435         const struct hda_channel_mode *channel_mode;
 436         int need_dac_fix;
 437         int const_channel_count;
 438         unsigned int num_mux_defs;
 439         const struct hda_input_mux *input_mux;
 440         void (*unsol_event)(struct hda_codec *, unsigned int);
 441         void (*setup)(struct hda_codec *);
 442         void (*init_hook)(struct hda_codec *);
 443 #ifdef CONFIG_SND_HDA_POWER_SAVE
 444         struct hda_amp_list *loopbacks;
 445         void (*power_hook)(struct hda_codec *codec);
 446 #endif
 447 };
 448
 449
 450 /*
 451  * input MUX handling
 452  */
 453 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 454                              struct snd_ctl_elem_info *uinfo)
 455 {
 456         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 457         struct alc_spec *spec = codec->spec;
 458         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 459         if (mux_idx >= spec->num_mux_defs)
 460                 mux_idx = 0;
 461         if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
 462                 mux_idx = 0;
 463         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 464 }
 465
 466 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 467                             struct snd_ctl_elem_value *ucontrol)
 468 {
 469         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 470         struct alc_spec *spec = codec->spec;
 471         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 472
 473         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 474         return 0;
 475 }
 476
 477 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 478                             struct snd_ctl_elem_value *ucontrol)
 479 {
 480         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 481         struct alc_spec *spec = codec->spec;
 482         const struct hda_input_mux *imux;
 483         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 484         unsigned int mux_idx;
 485         hda_nid_t nid = spec->capsrc_nids ?
 486                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 487         unsigned int type;
 488
 489         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 490         imux = &spec->input_mux[mux_idx];
 491         if (!imux->num_items && mux_idx > 0)
 492                 imux = &spec->input_mux[0];
 493
 494         type = get_wcaps_type(get_wcaps(codec, nid));
 495         if (type == AC_WID_AUD_MIX) {
 496                 /* Matrix-mixer style (e.g. ALC882) */
 497                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 498                 unsigned int i, idx;
 499
 500                 idx = ucontrol->value.enumerated.item[0];
 501                 if (idx >= imux->num_items)
 502                         idx = imux->num_items - 1;
 503                 if (*cur_val == idx)
 504                         return 0;
 505                 for (i = 0; i < imux->num_items; i++) {
 506                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 507                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 508                                                  imux->items[i].index,
 509                                                  HDA_AMP_MUTE, v);
 510                 }
 511                 *cur_val = idx;
 512                 return 1;
 513         } else {
 514                 /* MUX style (e.g. ALC880) */
 515                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 516                                              &spec->cur_mux[adc_idx]);
 517         }
 518 }
 519
 520 /*
 521  * channel mode setting
 522  */
 523 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 524                             struct snd_ctl_elem_info *uinfo)
 525 {
 526         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 527         struct alc_spec *spec = codec->spec;
 528         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 529                                     spec->num_channel_mode);
 530 }
 531
 532 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 533                            struct snd_ctl_elem_value *ucontrol)
 534 {
 535         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 536         struct alc_spec *spec = codec->spec;
 537         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 538                                    spec->num_channel_mode,
 539                                    spec->ext_channel_count);
 540 }
 541
 542 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 543                            struct snd_ctl_elem_value *ucontrol)
 544 {
 545         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 546         struct alc_spec *spec = codec->spec;
 547         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 548                                       spec->num_channel_mode,
 549                                       &spec->ext_channel_count);
 550         if (err >= 0 && !spec->const_channel_count) {
 551                 spec->multiout.max_channels = spec->ext_channel_count;
 552                 if (spec->need_dac_fix)
 553                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 554         }
 555         return err;
 556 }
 557
 558 /*
 559  * Control the mode of pin widget settings via the mixer.  "pc" is used
 560  * instead of "%" to avoid consequences of accidently treating the % as
 561  * being part of a format specifier.  Maximum allowed length of a value is
 562  * 63 characters plus NULL terminator.
 563  *
 564  * Note: some retasking pin complexes seem to ignore requests for input
 565  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 566  * are requested.  Therefore order this list so that this behaviour will not
 567  * cause problems when mixer clients move through the enum sequentially.
 568  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 569  * March 2006.
 570  */
 571 static char *alc_pin_mode_names[] = {
 572         "Mic 50pc bias", "Mic 80pc bias",
 573         "Line in", "Line out", "Headphone out",
 574 };
 575 static unsigned char alc_pin_mode_values[] = {
 576         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 577 };
 578 /* The control can present all 5 options, or it can limit the options based
 579  * in the pin being assumed to be exclusively an input or an output pin.  In
 580  * addition, "input" pins may or may not process the mic bias option
 581  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 582  * accept requests for bias as of chip versions up to March 2006) and/or
 583  * wiring in the computer.
 584  */
 585 #define ALC_PIN_DIR_IN              0x00
 586 #define ALC_PIN_DIR_OUT             0x01
 587 #define ALC_PIN_DIR_INOUT           0x02
 588 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 589 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 590
 591 /* Info about the pin modes supported by the different pin direction modes.
 592  * For each direction the minimum and maximum values are given.
 593  */
 594 static signed char alc_pin_mode_dir_info[5][2] = {
 595         { 0, 2 },    /* ALC_PIN_DIR_IN */
 596         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 597         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 598         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 599         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 600 };
 601 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 602 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 603 #define alc_pin_mode_n_items(_dir) \
 604         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 605
 606 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 607                              struct snd_ctl_elem_info *uinfo)
 608 {
 609         unsigned int item_num = uinfo->value.enumerated.item;
 610         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 611
 612         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 613         uinfo->count = 1;
 614         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 615
 616         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 617                 item_num = alc_pin_mode_min(dir);
 618         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 619         return 0;
 620 }
 621
 622 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 623                             struct snd_ctl_elem_value *ucontrol)
 624 {
 625         unsigned int i;
 626         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 627         hda_nid_t nid = kcontrol->private_value & 0xffff;
 628         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 629         long *valp = ucontrol->value.integer.value;
 630         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 631                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 632                                                  0x00);
 633
 634         /* Find enumerated value for current pinctl setting */
 635         i = alc_pin_mode_min(dir);
 636         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 637                 i++;
 638         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 639         return 0;
 640 }
 641
 642 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 643                             struct snd_ctl_elem_value *ucontrol)
 644 {
 645         signed int change;
 646         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 647         hda_nid_t nid = kcontrol->private_value & 0xffff;
 648         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 649         long val = *ucontrol->value.integer.value;
 650         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 651                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 652                                                  0x00);
 653
 654         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 655                 val = alc_pin_mode_min(dir);
 656
 657         change = pinctl != alc_pin_mode_values[val];
 658         if (change) {
 659                 /* Set pin mode to that requested */
 660                 snd_hda_codec_write_cache(codec, nid, 0,
 661                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 662                                           alc_pin_mode_values[val]);
 663
 664                 /* Also enable the retasking pin's input/output as required
 665                  * for the requested pin mode.  Enum values of 2 or less are
 666                  * input modes.
 667                  *
 668                  * Dynamically switching the input/output buffers probably
 669                  * reduces noise slightly (particularly on input) so we'll
 670                  * do it.  However, having both input and output buffers
 671                  * enabled simultaneously doesn't seem to be problematic if
 672                  * this turns out to be necessary in the future.
 673                  */
 674                 if (val <= 2) {
 675                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 676                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 677                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 678                                                  HDA_AMP_MUTE, 0);
 679                 } else {
 680                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 681                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 682                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 683                                                  HDA_AMP_MUTE, 0);
 684                 }
 685         }
 686         return change;
 687 }
 688
 689 #define ALC_PIN_MODE(xname, nid, dir) \
 690         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 691           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 692           .info = alc_pin_mode_info, \
 693           .get = alc_pin_mode_get, \
 694           .put = alc_pin_mode_put, \
 695           .private_value = nid | (dir<<16) }
 696
 697 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 698  * together using a mask with more than one bit set.  This control is
 699  * currently used only by the ALC260 test model.  At this stage they are not
 700  * needed for any "production" models.
 701  */
 702 #ifdef CONFIG_SND_DEBUG
 703 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 704
 705 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 706                              struct snd_ctl_elem_value *ucontrol)
 707 {
 708         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 709         hda_nid_t nid = kcontrol->private_value & 0xffff;
 710         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 711         long *valp = ucontrol->value.integer.value;
 712         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 713                                               AC_VERB_GET_GPIO_DATA, 0x00);
 714
 715         *valp = (val & mask) != 0;
 716         return 0;
 717 }
 718 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 719                              struct snd_ctl_elem_value *ucontrol)
 720 {
 721         signed int change;
 722         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 723         hda_nid_t nid = kcontrol->private_value & 0xffff;
 724         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 725         long val = *ucontrol->value.integer.value;
 726         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 727                                                     AC_VERB_GET_GPIO_DATA,
 728                                                     0x00);
 729
 730         /* Set/unset the masked GPIO bit(s) as needed */
 731         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 732         if (val == 0)
 733                 gpio_data &= ~mask;
 734         else
 735                 gpio_data |= mask;
 736         snd_hda_codec_write_cache(codec, nid, 0,
 737                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 738
 739         return change;
 740 }
 741 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 742         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 743           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 744           .info = alc_gpio_data_info, \
 745           .get = alc_gpio_data_get, \
 746           .put = alc_gpio_data_put, \
 747           .private_value = nid | (mask<<16) }
 748 #endif   /* CONFIG_SND_DEBUG */
 749
 750 /* A switch control to allow the enabling of the digital IO pins on the
 751  * ALC260.  This is incredibly simplistic; the intention of this control is
 752  * to provide something in the test model allowing digital outputs to be
 753  * identified if present.  If models are found which can utilise these
 754  * outputs a more complete mixer control can be devised for those models if
 755  * necessary.
 756  */
 757 #ifdef CONFIG_SND_DEBUG
 758 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 759
 760 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 761                               struct snd_ctl_elem_value *ucontrol)
 762 {
 763         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 764         hda_nid_t nid = kcontrol->private_value & 0xffff;
 765         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 766         long *valp = ucontrol->value.integer.value;
 767         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 768                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 769
 770         *valp = (val & mask) != 0;
 771         return 0;
 772 }
 773 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 774                               struct snd_ctl_elem_value *ucontrol)
 775 {
 776         signed int change;
 777         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 778         hda_nid_t nid = kcontrol->private_value & 0xffff;
 779         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 780         long val = *ucontrol->value.integer.value;
 781         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 782                                                     AC_VERB_GET_DIGI_CONVERT_1,
 783                                                     0x00);
 784
 785         /* Set/unset the masked control bit(s) as needed */
 786         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 787         if (val==0)
 788                 ctrl_data &= ~mask;
 789         else
 790                 ctrl_data |= mask;
 791         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 792                                   ctrl_data);
 793
 794         return change;
 795 }
 796 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 797         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 798           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 799           .info = alc_spdif_ctrl_info, \
 800           .get = alc_spdif_ctrl_get, \
 801           .put = alc_spdif_ctrl_put, \
 802           .private_value = nid | (mask<<16) }
 803 #endif   /* CONFIG_SND_DEBUG */
 804
 805 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 806  * Again, this is only used in the ALC26x test models to help identify when
 807  * the EAPD line must be asserted for features to work.
 808  */
 809 #ifdef CONFIG_SND_DEBUG
 810 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 811
 812 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 813                               struct snd_ctl_elem_value *ucontrol)
 814 {
 815         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 816         hda_nid_t nid = kcontrol->private_value & 0xffff;
 817         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 818         long *valp = ucontrol->value.integer.value;
 819         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 820                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 821
 822         *valp = (val & mask) != 0;
 823         return 0;
 824 }
 825
 826 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 827                               struct snd_ctl_elem_value *ucontrol)
 828 {
 829         int change;
 830         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 831         hda_nid_t nid = kcontrol->private_value & 0xffff;
 832         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 833         long val = *ucontrol->value.integer.value;
 834         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 835                                                     AC_VERB_GET_EAPD_BTLENABLE,
 836                                                     0x00);
 837
 838         /* Set/unset the masked control bit(s) as needed */
 839         change = (!val ? 0 : mask) != (ctrl_data & mask);
 840         if (!val)
 841                 ctrl_data &= ~mask;
 842         else
 843                 ctrl_data |= mask;
 844         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 845                                   ctrl_data);
 846
 847         return change;
 848 }
 849
 850 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 851         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 852           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 853           .info = alc_eapd_ctrl_info, \
 854           .get = alc_eapd_ctrl_get, \
 855           .put = alc_eapd_ctrl_put, \
 856           .private_value = nid | (mask<<16) }
 857 #endif   /* CONFIG_SND_DEBUG */
 858
 859 /*
 860  * set up the input pin config (depending on the given auto-pin type)
 861  */
 862 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 863                               int auto_pin_type)
 864 {
 865         unsigned int val = PIN_IN;
 866
 867         if (auto_pin_type == AUTO_PIN_MIC) {
 868                 unsigned int pincap;
 869                 unsigned int oldval;
 870                 oldval = snd_hda_codec_read(codec, nid, 0,
 871                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 872                 pincap = snd_hda_query_pin_caps(codec, nid);
 873                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 874                 /* if the default pin setup is vref50, we give it priority */
 875                 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
 876                         val = PIN_VREF80;
 877                 else if (pincap & AC_PINCAP_VREF_50)
 878                         val = PIN_VREF50;
 879                 else if (pincap & AC_PINCAP_VREF_100)
 880                         val = PIN_VREF100;
 881                 else if (pincap & AC_PINCAP_VREF_GRD)
 882                         val = PIN_VREFGRD;
 883         }
 884         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 885 }
 886
 887 static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec)
 888 {
 889         struct alc_spec *spec = codec->spec;
 890         struct auto_pin_cfg *cfg = &spec->autocfg;
 891
 892         if (!cfg->line_outs) {
 893                 while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
 894                        cfg->line_out_pins[cfg->line_outs])
 895                         cfg->line_outs++;
 896         }
 897         if (!cfg->speaker_outs) {
 898                 while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
 899                        cfg->speaker_pins[cfg->speaker_outs])
 900                         cfg->speaker_outs++;
 901         }
 902         if (!cfg->hp_outs) {
 903                 while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
 904                        cfg->hp_pins[cfg->hp_outs])
 905                         cfg->hp_outs++;
 906         }
 907 }
 908
 909 /*
 910  */
 911 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 912 {
 913         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 914                 return;
 915         spec->mixers[spec->num_mixers++] = mix;
 916 }
 917
 918 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 919 {
 920         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 921                 return;
 922         spec->init_verbs[spec->num_init_verbs++] = verb;
 923 }
 924
 925 /*
 926  * set up from the preset table
 927  */
 928 static void setup_preset(struct hda_codec *codec,
 929                          const struct alc_config_preset *preset)
 930 {
 931         struct alc_spec *spec = codec->spec;
 932         int i;
 933
 934         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 935                 add_mixer(spec, preset->mixers[i]);
 936         spec->cap_mixer = preset->cap_mixer;
 937         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 938              i++)
 939                 add_verb(spec, preset->init_verbs[i]);
 940
 941         spec->channel_mode = preset->channel_mode;
 942         spec->num_channel_mode = preset->num_channel_mode;
 943         spec->need_dac_fix = preset->need_dac_fix;
 944         spec->const_channel_count = preset->const_channel_count;
 945
 946         if (preset->const_channel_count)
 947                 spec->multiout.max_channels = preset->const_channel_count;
 948         else
 949                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 950         spec->ext_channel_count = spec->channel_mode[0].channels;
 951
 952         spec->multiout.num_dacs = preset->num_dacs;
 953         spec->multiout.dac_nids = preset->dac_nids;
 954         spec->multiout.dig_out_nid = preset->dig_out_nid;
 955         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 956         spec->multiout.hp_nid = preset->hp_nid;
 957
 958         spec->num_mux_defs = preset->num_mux_defs;
 959         if (!spec->num_mux_defs)
 960                 spec->num_mux_defs = 1;
 961         spec->input_mux = preset->input_mux;
 962
 963         spec->num_adc_nids = preset->num_adc_nids;
 964         spec->adc_nids = preset->adc_nids;
 965         spec->capsrc_nids = preset->capsrc_nids;
 966         spec->dig_in_nid = preset->dig_in_nid;
 967
 968         spec->unsol_event = preset->unsol_event;
 969         spec->init_hook = preset->init_hook;
 970 #ifdef CONFIG_SND_HDA_POWER_SAVE
 971         spec->power_hook = preset->power_hook;
 972         spec->loopback.amplist = preset->loopbacks;
 973 #endif
 974
 975         if (preset->setup)
 976                 preset->setup(codec);
 977
 978         alc_fixup_autocfg_pin_nums(codec);
 979 }
 980
 981 /* Enable GPIO mask and set output */
 982 static struct hda_verb alc_gpio1_init_verbs[] = {
 983         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 984         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 985         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 986         { }
 987 };
 988
 989 static struct hda_verb alc_gpio2_init_verbs[] = {
 990         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 991         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 992         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 993         { }
 994 };
 995
 996 static struct hda_verb alc_gpio3_init_verbs[] = {
 997         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 998         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 999         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
1000         { }
1001 };
1002
1003 /*
1004  * Fix hardware PLL issue
1005  * On some codecs, the analog PLL gating control must be off while
1006  * the default value is 1.
1007  */
1008 static void alc_fix_pll(struct hda_codec *codec)
1009 {
1010         struct alc_spec *spec = codec->spec;
1011         unsigned int val;
1012
1013         if (!spec->pll_nid)
1014                 return;
1015         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1016                             spec->pll_coef_idx);
1017         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
1018                                  AC_VERB_GET_PROC_COEF, 0);
1019         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1020                             spec->pll_coef_idx);
1021         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
1022                             val & ~(1 << spec->pll_coef_bit));
1023 }
1024
1025 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
1026                              unsigned int coef_idx, unsigned int coef_bit)
1027 {
1028         struct alc_spec *spec = codec->spec;
1029         spec->pll_nid = nid;
1030         spec->pll_coef_idx = coef_idx;
1031         spec->pll_coef_bit = coef_bit;
1032         alc_fix_pll(codec);
1033 }
1034
1035 #ifdef CONFIG_SND_HDA_INPUT_JACK
1036 static void alc_free_jack_priv(struct snd_jack *jack)
1037 {
1038         struct alc_jack *jacks = jack->private_data;
1039         jacks->nid = 0;
1040         jacks->jack = NULL;
1041 }
1042
1043 static int alc_add_jack(struct hda_codec *codec,
1044                 hda_nid_t nid, int type)
1045 {
1046         struct alc_spec *spec;
1047         struct alc_jack *jack;
1048         const char *name;
1049         int err;
1050
1051         spec = codec->spec;
1052         snd_array_init(&spec->jacks, sizeof(*jack), 32);
1053         jack = snd_array_new(&spec->jacks);
1054         if (!jack)
1055                 return -ENOMEM;
1056
1057         jack->nid = nid;
1058         jack->type = type;
1059         name = (type == SND_JACK_HEADPHONE) ? "Headphone" : "Mic" ;
1060
1061         err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
1062         if (err < 0)
1063                 return err;
1064         jack->jack->private_data = jack;
1065         jack->jack->private_free = alc_free_jack_priv;
1066         return 0;
1067 }
1068
1069 static void alc_report_jack(struct hda_codec *codec, hda_nid_t nid)
1070 {
1071         struct alc_spec *spec = codec->spec;
1072         struct alc_jack *jacks = spec->jacks.list;
1073
1074         if (jacks) {
1075                 int i;
1076                 for (i = 0; i < spec->jacks.used; i++) {
1077                         if (jacks->nid == nid) {
1078                                 unsigned int present;
1079                                 present = snd_hda_jack_detect(codec, nid);
1080
1081                                 present = (present) ? jacks->type : 0;
1082
1083                                 snd_jack_report(jacks->jack, present);
1084                         }
1085                         jacks++;
1086                 }
1087         }
1088 }
1089
1090 static int alc_init_jacks(struct hda_codec *codec)
1091 {
1092         struct alc_spec *spec = codec->spec;
1093         int err;
1094         unsigned int hp_nid = spec->autocfg.hp_pins[0];
1095         unsigned int mic_nid = spec->ext_mic.pin;
1096
1097         if (hp_nid) {
1098                 err = alc_add_jack(codec, hp_nid, SND_JACK_HEADPHONE);
1099                 if (err < 0)
1100                         return err;
1101                 alc_report_jack(codec, hp_nid);
1102         }
1103
1104         if (mic_nid) {
1105                 err = alc_add_jack(codec, mic_nid, SND_JACK_MICROPHONE);
1106                 if (err < 0)
1107                         return err;
1108                 alc_report_jack(codec, mic_nid);
1109         }
1110
1111         return 0;
1112 }
1113 #else
1114 static inline void alc_report_jack(struct hda_codec *codec, hda_nid_t nid)
1115 {
1116 }
1117
1118 static inline int alc_init_jacks(struct hda_codec *codec)
1119 {
1120         return 0;
1121 }
1122 #endif
1123
1124 static void alc_automute_speaker(struct hda_codec *codec, int pinctl)
1125 {
1126         struct alc_spec *spec = codec->spec;
1127         unsigned int mute;
1128         hda_nid_t nid;
1129         int i;
1130
1131         spec->jack_present = 0;
1132         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1133                 nid = spec->autocfg.hp_pins[i];
1134                 if (!nid)
1135                         break;
1136                 alc_report_jack(codec, nid);
1137                 spec->jack_present |= snd_hda_jack_detect(codec, nid);
1138         }
1139
1140         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1141         /* Toggle internal speakers muting */
1142         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1143                 nid = spec->autocfg.speaker_pins[i];
1144                 if (!nid)
1145                         break;
1146                 if (pinctl) {
1147                         snd_hda_codec_write(codec, nid, 0,
1148                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1149                                     spec->jack_present ? 0 : PIN_OUT);
1150                 } else {
1151                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1152                                          HDA_AMP_MUTE, mute);
1153                 }
1154         }
1155 }
1156
1157 static void alc_automute_pin(struct hda_codec *codec)
1158 {
1159         alc_automute_speaker(codec, 1);
1160 }
1161
1162 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
1163                                 hda_nid_t nid)
1164 {
1165         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
1166         int i, nums;
1167
1168         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
1169         for (i = 0; i < nums; i++)
1170                 if (conn[i] == nid)
1171                         return i;
1172         return -1;
1173 }
1174
1175 /* switch the current ADC according to the jack state */
1176 static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec)
1177 {
1178         struct alc_spec *spec = codec->spec;
1179         unsigned int present;
1180         hda_nid_t new_adc;
1181
1182         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1183         if (present)
1184                 spec->cur_adc_idx = 1;
1185         else
1186                 spec->cur_adc_idx = 0;
1187         new_adc = spec->adc_nids[spec->cur_adc_idx];
1188         if (spec->cur_adc && spec->cur_adc != new_adc) {
1189                 /* stream is running, let's swap the current ADC */
1190                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1191                 spec->cur_adc = new_adc;
1192                 snd_hda_codec_setup_stream(codec, new_adc,
1193                                            spec->cur_adc_stream_tag, 0,
1194                                            spec->cur_adc_format);
1195         }
1196 }
1197
1198 static void alc_mic_automute(struct hda_codec *codec)
1199 {
1200         struct alc_spec *spec = codec->spec;
1201         struct alc_mic_route *dead, *alive;
1202         unsigned int present, type;
1203         hda_nid_t cap_nid;
1204
1205         if (!spec->auto_mic)
1206                 return;
1207         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1208                 return;
1209         if (snd_BUG_ON(!spec->adc_nids))
1210                 return;
1211
1212         if (spec->dual_adc_switch) {
1213                 alc_dual_mic_adc_auto_switch(codec);
1214                 return;
1215         }
1216
1217         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1218
1219         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1220         if (present) {
1221                 alive = &spec->ext_mic;
1222                 dead = &spec->int_mic;
1223         } else {
1224                 alive = &spec->int_mic;
1225                 dead = &spec->ext_mic;
1226         }
1227
1228         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1229         if (type == AC_WID_AUD_MIX) {
1230                 /* Matrix-mixer style (e.g. ALC882) */
1231                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1232                                          alive->mux_idx,
1233                                          HDA_AMP_MUTE, 0);
1234                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1235                                          dead->mux_idx,
1236                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1237         } else {
1238                 /* MUX style (e.g. ALC880) */
1239                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1240                                           AC_VERB_SET_CONNECT_SEL,
1241                                           alive->mux_idx);
1242         }
1243         alc_report_jack(codec, spec->ext_mic.pin);
1244
1245         /* FIXME: analog mixer */
1246 }
1247
1248 /* unsolicited event for HP jack sensing */
1249 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1250 {
1251         if (codec->vendor_id == 0x10ec0880)
1252                 res >>= 28;
1253         else
1254                 res >>= 26;
1255         switch (res) {
1256         case ALC880_HP_EVENT:
1257                 alc_automute_pin(codec);
1258                 break;
1259         case ALC880_MIC_EVENT:
1260                 alc_mic_automute(codec);
1261                 break;
1262         }
1263 }
1264
1265 static void alc_inithook(struct hda_codec *codec)
1266 {
1267         alc_automute_pin(codec);
1268         alc_mic_automute(codec);
1269 }
1270
1271 /* additional initialization for ALC888 variants */
1272 static void alc888_coef_init(struct hda_codec *codec)
1273 {
1274         unsigned int tmp;
1275
1276         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1277         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1278         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1279         if ((tmp & 0xf0) == 0x20)
1280                 /* alc888S-VC */
1281                 snd_hda_codec_read(codec, 0x20, 0,
1282                                    AC_VERB_SET_PROC_COEF, 0x830);
1283          else
1284                  /* alc888-VB */
1285                  snd_hda_codec_read(codec, 0x20, 0,
1286                                     AC_VERB_SET_PROC_COEF, 0x3030);
1287 }
1288
1289 static void alc889_coef_init(struct hda_codec *codec)
1290 {
1291         unsigned int tmp;
1292
1293         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1294         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1295         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1296         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1297 }
1298
1299 /* turn on/off EAPD control (only if available) */
1300 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1301 {
1302         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1303                 return;
1304         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1305                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1306                                     on ? 2 : 0);
1307 }
1308
1309 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1310 {
1311         unsigned int tmp;
1312
1313         switch (type) {
1314         case ALC_INIT_GPIO1:
1315                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1316                 break;
1317         case ALC_INIT_GPIO2:
1318                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1319                 break;
1320         case ALC_INIT_GPIO3:
1321                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1322                 break;
1323         case ALC_INIT_DEFAULT:
1324                 switch (codec->vendor_id) {
1325                 case 0x10ec0260:
1326                         set_eapd(codec, 0x0f, 1);
1327                         set_eapd(codec, 0x10, 1);
1328                         break;
1329                 case 0x10ec0262:
1330                 case 0x10ec0267:
1331                 case 0x10ec0268:
1332                 case 0x10ec0269:
1333                 case 0x10ec0270:
1334                 case 0x10ec0272:
1335                 case 0x10ec0660:
1336                 case 0x10ec0662:
1337                 case 0x10ec0663:
1338                 case 0x10ec0862:
1339                 case 0x10ec0889:
1340                         set_eapd(codec, 0x14, 1);
1341                         set_eapd(codec, 0x15, 1);
1342                         break;
1343                 }
1344                 switch (codec->vendor_id) {
1345                 case 0x10ec0260:
1346                         snd_hda_codec_write(codec, 0x1a, 0,
1347                                             AC_VERB_SET_COEF_INDEX, 7);
1348                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1349                                                  AC_VERB_GET_PROC_COEF, 0);
1350                         snd_hda_codec_write(codec, 0x1a, 0,
1351                                             AC_VERB_SET_COEF_INDEX, 7);
1352                         snd_hda_codec_write(codec, 0x1a, 0,
1353                                             AC_VERB_SET_PROC_COEF,
1354                                             tmp | 0x2010);
1355                         break;
1356                 case 0x10ec0262:
1357                 case 0x10ec0880:
1358                 case 0x10ec0882:
1359                 case 0x10ec0883:
1360                 case 0x10ec0885:
1361                 case 0x10ec0887:
1362                 case 0x10ec0889:
1363                         alc889_coef_init(codec);
1364                         break;
1365                 case 0x10ec0888:
1366                         alc888_coef_init(codec);
1367                         break;
1368 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
1369                 case 0x10ec0267:
1370                 case 0x10ec0268:
1371                         snd_hda_codec_write(codec, 0x20, 0,
1372                                             AC_VERB_SET_COEF_INDEX, 7);
1373                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1374                                                  AC_VERB_GET_PROC_COEF, 0);
1375                         snd_hda_codec_write(codec, 0x20, 0,
1376                                             AC_VERB_SET_COEF_INDEX, 7);
1377                         snd_hda_codec_write(codec, 0x20, 0,
1378                                             AC_VERB_SET_PROC_COEF,
1379                                             tmp | 0x3000);
1380                         break;
1381 #endif /* XXX */
1382                 }
1383                 break;
1384         }
1385 }
1386
1387 static void alc_init_auto_hp(struct hda_codec *codec)
1388 {
1389         struct alc_spec *spec = codec->spec;
1390         struct auto_pin_cfg *cfg = &spec->autocfg;
1391         int i;
1392
1393         if (!cfg->hp_pins[0]) {
1394                 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1395                         return;
1396         }
1397
1398         if (!cfg->speaker_pins[0]) {
1399                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1400                         return;
1401                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1402                        sizeof(cfg->speaker_pins));
1403                 cfg->speaker_outs = cfg->line_outs;
1404         }
1405
1406         if (!cfg->hp_pins[0]) {
1407                 memcpy(cfg->hp_pins, cfg->line_out_pins,
1408                        sizeof(cfg->hp_pins));
1409                 cfg->hp_outs = cfg->line_outs;
1410         }
1411
1412         for (i = 0; i < cfg->hp_outs; i++) {
1413                 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1414                             cfg->hp_pins[i]);
1415                 snd_hda_codec_write_cache(codec, cfg->hp_pins[i], 0,
1416                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1417                                   AC_USRSP_EN | ALC880_HP_EVENT);
1418         }
1419         spec->unsol_event = alc_sku_unsol_event;
1420 }
1421
1422 static void alc_init_auto_mic(struct hda_codec *codec)
1423 {
1424         struct alc_spec *spec = codec->spec;
1425         struct auto_pin_cfg *cfg = &spec->autocfg;
1426         hda_nid_t fixed, ext;
1427         int i;
1428
1429         /* there must be only two mic inputs exclusively */
1430         for (i = 0; i < cfg->num_inputs; i++)
1431                 if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN)
1432                         return;
1433
1434         fixed = ext = 0;
1435         for (i = 0; i < cfg->num_inputs; i++) {
1436                 hda_nid_t nid = cfg->inputs[i].pin;
1437                 unsigned int defcfg;
1438                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1439                 switch (snd_hda_get_input_pin_attr(defcfg)) {
1440                 case INPUT_PIN_ATTR_INT:
1441                         if (fixed)
1442                                 return; /* already occupied */
1443                         fixed = nid;
1444                         break;
1445                 case INPUT_PIN_ATTR_UNUSED:
1446                         return; /* invalid entry */
1447                 default:
1448                         if (ext)
1449                                 return; /* already occupied */
1450                         ext = nid;
1451                         break;
1452                 }
1453         }
1454         if (!ext || !fixed)
1455                 return;
1456         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1457                 return; /* no unsol support */
1458         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1459                     ext, fixed);
1460         spec->ext_mic.pin = ext;
1461         spec->int_mic.pin = fixed;
1462         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1463         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1464         spec->auto_mic = 1;
1465         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1466                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1467                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1468         spec->unsol_event = alc_sku_unsol_event;
1469 }
1470
1471 /* Could be any non-zero and even value. When used as fixup, tells
1472  * the driver to ignore any present sku defines.
1473  */
1474 #define ALC_FIXUP_SKU_IGNORE (2)
1475
1476 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1477 {
1478         unsigned int ass, tmp, i;
1479         unsigned nid = 0;
1480         struct alc_spec *spec = codec->spec;
1481
1482         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1483
1484         if (spec->cdefine.fixup) {
1485                 ass = spec->cdefine.sku_cfg;
1486                 if (ass == ALC_FIXUP_SKU_IGNORE)
1487                         return -1;
1488                 goto do_sku;
1489         }
1490
1491         ass = codec->subsystem_id & 0xffff;
1492         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1493                 goto do_sku;
1494
1495         nid = 0x1d;
1496         if (codec->vendor_id == 0x10ec0260)
1497                 nid = 0x17;
1498         ass = snd_hda_codec_get_pincfg(codec, nid);
1499
1500         if (!(ass & 1)) {
1501                 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1502                        codec->chip_name, ass);
1503                 return -1;
1504         }
1505
1506         /* check sum */
1507         tmp = 0;
1508         for (i = 1; i < 16; i++) {
1509                 if ((ass >> i) & 1)
1510                         tmp++;
1511         }
1512         if (((ass >> 16) & 0xf) != tmp)
1513                 return -1;
1514
1515         spec->cdefine.port_connectivity = ass >> 30;
1516         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1517         spec->cdefine.check_sum = (ass >> 16) & 0xf;
1518         spec->cdefine.customization = ass >> 8;
1519 do_sku:
1520         spec->cdefine.sku_cfg = ass;
1521         spec->cdefine.external_amp = (ass & 0x38) >> 3;
1522         spec->cdefine.platform_type = (ass & 0x4) >> 2;
1523         spec->cdefine.swap = (ass & 0x2) >> 1;
1524         spec->cdefine.override = ass & 0x1;
1525
1526         snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1527                    nid, spec->cdefine.sku_cfg);
1528         snd_printd("SKU: port_connectivity=0x%x\n",
1529                    spec->cdefine.port_connectivity);
1530         snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1531         snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1532         snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1533         snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1534         snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1535         snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1536         snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1537
1538         return 0;
1539 }
1540
1541 /* check subsystem ID and set up device-specific initialization;
1542  * return 1 if initialized, 0 if invalid SSID
1543  */
1544 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1545  *      31 ~ 16 :       Manufacture ID
1546  *      15 ~ 8  :       SKU ID
1547  *      7  ~ 0  :       Assembly ID
1548  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1549  */
1550 static int alc_subsystem_id(struct hda_codec *codec,
1551                             hda_nid_t porta, hda_nid_t porte,
1552                             hda_nid_t portd, hda_nid_t porti)
1553 {
1554         unsigned int ass, tmp, i;
1555         unsigned nid;
1556         struct alc_spec *spec = codec->spec;
1557
1558         if (spec->cdefine.fixup) {
1559                 ass = spec->cdefine.sku_cfg;
1560                 if (ass == ALC_FIXUP_SKU_IGNORE)
1561                         return 0;
1562                 goto do_sku;
1563         }
1564
1565         ass = codec->subsystem_id & 0xffff;
1566         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1567                 goto do_sku;
1568
1569         /* invalid SSID, check the special NID pin defcfg instead */
1570         /*
1571          * 31~30        : port connectivity
1572          * 29~21        : reserve
1573          * 20           : PCBEEP input
1574          * 19~16        : Check sum (15:1)
1575          * 15~1         : Custom
1576          * 0            : override
1577         */
1578         nid = 0x1d;
1579         if (codec->vendor_id == 0x10ec0260)
1580                 nid = 0x17;
1581         ass = snd_hda_codec_get_pincfg(codec, nid);
1582         snd_printd("realtek: No valid SSID, "
1583                    "checking pincfg 0x%08x for NID 0x%x\n",
1584                    ass, nid);
1585         if (!(ass & 1))
1586                 return 0;
1587         if ((ass >> 30) != 1)   /* no physical connection */
1588                 return 0;
1589
1590         /* check sum */
1591         tmp = 0;
1592         for (i = 1; i < 16; i++) {
1593                 if ((ass >> i) & 1)
1594                         tmp++;
1595         }
1596         if (((ass >> 16) & 0xf) != tmp)
1597                 return 0;
1598 do_sku:
1599         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1600                    ass & 0xffff, codec->vendor_id);
1601         /*
1602          * 0 : override
1603          * 1 :  Swap Jack
1604          * 2 : 0 --> Desktop, 1 --> Laptop
1605          * 3~5 : External Amplifier control
1606          * 7~6 : Reserved
1607         */
1608         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1609         switch (tmp) {
1610         case 1:
1611                 spec->init_amp = ALC_INIT_GPIO1;
1612                 break;
1613         case 3:
1614                 spec->init_amp = ALC_INIT_GPIO2;
1615                 break;
1616         case 7:
1617                 spec->init_amp = ALC_INIT_GPIO3;
1618                 break;
1619         case 5:
1620         default:
1621                 spec->init_amp = ALC_INIT_DEFAULT;
1622                 break;
1623         }
1624
1625         /* is laptop or Desktop and enable the function "Mute internal speaker
1626          * when the external headphone out jack is plugged"
1627          */
1628         if (!(ass & 0x8000))
1629                 return 1;
1630         /*
1631          * 10~8 : Jack location
1632          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1633          * 14~13: Resvered
1634          * 15   : 1 --> enable the function "Mute internal speaker
1635          *              when the external headphone out jack is plugged"
1636          */
1637         if (!spec->autocfg.hp_pins[0]) {
1638                 hda_nid_t nid;
1639                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1640                 if (tmp == 0)
1641                         nid = porta;
1642                 else if (tmp == 1)
1643                         nid = porte;
1644                 else if (tmp == 2)
1645                         nid = portd;
1646                 else if (tmp == 3)
1647                         nid = porti;
1648                 else
1649                         return 1;
1650                 for (i = 0; i < spec->autocfg.line_outs; i++)
1651                         if (spec->autocfg.line_out_pins[i] == nid)
1652                                 return 1;
1653                 spec->autocfg.hp_pins[0] = nid;
1654         }
1655
1656         alc_init_auto_hp(codec);
1657         alc_init_auto_mic(codec);
1658         return 1;
1659 }
1660
1661 static void alc_ssid_check(struct hda_codec *codec,
1662                            hda_nid_t porta, hda_nid_t porte,
1663                            hda_nid_t portd, hda_nid_t porti)
1664 {
1665         if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1666                 struct alc_spec *spec = codec->spec;
1667                 snd_printd("realtek: "
1668                            "Enable default setup for auto mode as fallback\n");
1669                 spec->init_amp = ALC_INIT_DEFAULT;
1670                 alc_init_auto_hp(codec);
1671                 alc_init_auto_mic(codec);
1672         }
1673 }
1674
1675 /*
1676  * Fix-up pin default configurations and add default verbs
1677  */
1678
1679 struct alc_pincfg {
1680         hda_nid_t nid;
1681         u32 val;
1682 };
1683
1684 struct alc_model_fixup {
1685         const int id;
1686         const char *name;
1687 };
1688
1689 struct alc_fixup {
1690         int type;
1691         bool chained;
1692         int chain_id;
1693         union {
1694                 unsigned int sku;
1695                 const struct alc_pincfg *pins;
1696                 const struct hda_verb *verbs;
1697                 void (*func)(struct hda_codec *codec,
1698                              const struct alc_fixup *fix,
1699                              int action);
1700         } v;
1701 };
1702
1703 enum {
1704         ALC_FIXUP_INVALID,
1705         ALC_FIXUP_SKU,
1706         ALC_FIXUP_PINS,
1707         ALC_FIXUP_VERBS,
1708         ALC_FIXUP_FUNC,
1709 };
1710
1711 enum {
1712         ALC_FIXUP_ACT_PRE_PROBE,
1713         ALC_FIXUP_ACT_PROBE,
1714         ALC_FIXUP_ACT_INIT,
1715 };
1716
1717 static void alc_apply_fixup(struct hda_codec *codec, int action)
1718 {
1719         struct alc_spec *spec = codec->spec;
1720         int id = spec->fixup_id;
1721 #ifdef CONFIG_SND_DEBUG_VERBOSE
1722         const char *modelname = spec->fixup_name;
1723 #endif
1724         int depth = 0;
1725
1726         if (!spec->fixup_list)
1727                 return;
1728
1729         while (id >= 0) {
1730                 const struct alc_fixup *fix = spec->fixup_list + id;
1731                 const struct alc_pincfg *cfg;
1732
1733                 switch (fix->type) {
1734                 case ALC_FIXUP_SKU:
1735                         if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1736                                 break;;
1737                         snd_printdd(KERN_INFO "hda_codec: %s: "
1738                                     "Apply sku override for %s\n",
1739                                     codec->chip_name, modelname);
1740                         spec->cdefine.sku_cfg = fix->v.sku;
1741                         spec->cdefine.fixup = 1;
1742                         break;
1743                 case ALC_FIXUP_PINS:
1744                         cfg = fix->v.pins;
1745                         if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1746                                 break;
1747                         snd_printdd(KERN_INFO "hda_codec: %s: "
1748                                     "Apply pincfg for %s\n",
1749                                     codec->chip_name, modelname);
1750                         for (; cfg->nid; cfg++)
1751                                 snd_hda_codec_set_pincfg(codec, cfg->nid,
1752                                                          cfg->val);
1753                         break;
1754                 case ALC_FIXUP_VERBS:
1755                         if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1756                                 break;
1757                         snd_printdd(KERN_INFO "hda_codec: %s: "
1758                                     "Apply fix-verbs for %s\n",
1759                                     codec->chip_name, modelname);
1760                         add_verb(codec->spec, fix->v.verbs);
1761                         break;
1762                 case ALC_FIXUP_FUNC:
1763                         if (!fix->v.func)
1764                                 break;
1765                         snd_printdd(KERN_INFO "hda_codec: %s: "
1766                                     "Apply fix-func for %s\n",
1767                                     codec->chip_name, modelname);
1768                         fix->v.func(codec, fix, action);
1769                         break;
1770                 default:
1771                         snd_printk(KERN_ERR "hda_codec: %s: "
1772                                    "Invalid fixup type %d\n",
1773                                    codec->chip_name, fix->type);
1774                         break;
1775                 }
1776                 if (!fix[id].chained)
1777                         break;
1778                 if (++depth > 10)
1779                         break;
1780                 id = fix[id].chain_id;
1781         }
1782 }
1783
1784 static void alc_pick_fixup(struct hda_codec *codec,
1785                            const struct alc_model_fixup *models,
1786                            const struct snd_pci_quirk *quirk,
1787                            const struct alc_fixup *fixlist)
1788 {
1789         struct alc_spec *spec = codec->spec;
1790         int id = -1;
1791         const char *name = NULL;
1792
1793         if (codec->modelname && models) {
1794                 while (models->name) {
1795                         if (!strcmp(codec->modelname, models->name)) {
1796                                 id = models->id;
1797                                 name = models->name;
1798                                 break;
1799                         }
1800                         models++;
1801                 }
1802         }
1803         if (id < 0) {
1804                 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1805                 if (quirk) {
1806                         id = quirk->value;
1807 #ifdef CONFIG_SND_DEBUG_VERBOSE
1808                         name = quirk->name;
1809 #endif
1810                 }
1811         }
1812
1813         spec->fixup_id = id;
1814         if (id >= 0) {
1815                 spec->fixup_list = fixlist;
1816                 spec->fixup_name = name;
1817         }
1818 }
1819
1820 static int alc_read_coef_idx(struct hda_codec *codec,
1821                         unsigned int coef_idx)
1822 {
1823         unsigned int val;
1824         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1825                                 coef_idx);
1826         val = snd_hda_codec_read(codec, 0x20, 0,
1827                                 AC_VERB_GET_PROC_COEF, 0);
1828         return val;
1829 }
1830
1831 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1832                                                         unsigned int coef_val)
1833 {
1834         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1835                             coef_idx);
1836         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1837                             coef_val);
1838 }
1839
1840 /* set right pin controls for digital I/O */
1841 static void alc_auto_init_digital(struct hda_codec *codec)
1842 {
1843         struct alc_spec *spec = codec->spec;
1844         int i;
1845         hda_nid_t pin;
1846
1847         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1848                 pin = spec->autocfg.dig_out_pins[i];
1849                 if (pin) {
1850                         snd_hda_codec_write(codec, pin, 0,
1851                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1852                                             PIN_OUT);
1853                 }
1854         }
1855         pin = spec->autocfg.dig_in_pin;
1856         if (pin)
1857                 snd_hda_codec_write(codec, pin, 0,
1858                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1859                                     PIN_IN);
1860 }
1861
1862 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1863 static void alc_auto_parse_digital(struct hda_codec *codec)
1864 {
1865         struct alc_spec *spec = codec->spec;
1866         int i, err;
1867         hda_nid_t dig_nid;
1868
1869         /* support multiple SPDIFs; the secondary is set up as a slave */
1870         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1871                 err = snd_hda_get_connections(codec,
1872                                               spec->autocfg.dig_out_pins[i],
1873                                               &dig_nid, 1);
1874                 if (err < 0)
1875                         continue;
1876                 if (!i) {
1877                         spec->multiout.dig_out_nid = dig_nid;
1878                         spec->dig_out_type = spec->autocfg.dig_out_type[0];
1879                 } else {
1880                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1881                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1882                                 break;
1883                         spec->slave_dig_outs[i - 1] = dig_nid;
1884                 }
1885         }
1886
1887         if (spec->autocfg.dig_in_pin) {
1888                 dig_nid = codec->start_nid;
1889                 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1890                         unsigned int wcaps = get_wcaps(codec, dig_nid);
1891                         if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1892                                 continue;
1893                         if (!(wcaps & AC_WCAP_DIGITAL))
1894                                 continue;
1895                         if (!(wcaps & AC_WCAP_CONN_LIST))
1896                                 continue;
1897                         err = get_connection_index(codec, dig_nid,
1898                                                    spec->autocfg.dig_in_pin);
1899                         if (err >= 0) {
1900                                 spec->dig_in_nid = dig_nid;
1901                                 break;
1902                         }
1903                 }
1904         }
1905 }
1906
1907 /*
1908  * ALC888
1909  */
1910
1911 /*
1912  * 2ch mode
1913  */
1914 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1915 /* Mic-in jack as mic in */
1916         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1917         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1918 /* Line-in jack as Line in */
1919         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1920         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1921 /* Line-Out as Front */
1922         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1923         { } /* end */
1924 };
1925
1926 /*
1927  * 4ch mode
1928  */
1929 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1930 /* Mic-in jack as mic in */
1931         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1932         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1933 /* Line-in jack as Surround */
1934         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1935         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1936 /* Line-Out as Front */
1937         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1938         { } /* end */
1939 };
1940
1941 /*
1942  * 6ch mode
1943  */
1944 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1945 /* Mic-in jack as CLFE */
1946         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1947         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1948 /* Line-in jack as Surround */
1949         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1950         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1951 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1952         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1953         { } /* end */
1954 };
1955
1956 /*
1957  * 8ch mode
1958  */
1959 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1960 /* Mic-in jack as CLFE */
1961         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1962         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1963 /* Line-in jack as Surround */
1964         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1965         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1966 /* Line-Out as Side */
1967         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1968         { } /* end */
1969 };
1970
1971 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1972         { 2, alc888_4ST_ch2_intel_init },
1973         { 4, alc888_4ST_ch4_intel_init },
1974         { 6, alc888_4ST_ch6_intel_init },
1975         { 8, alc888_4ST_ch8_intel_init },
1976 };
1977
1978 /*
1979  * ALC888 Fujitsu Siemens Amillo xa3530
1980  */
1981
1982 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1983 /* Front Mic: set to PIN_IN (empty by default) */
1984         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1985 /* Connect Internal HP to Front */
1986         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1987         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1988         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1989 /* Connect Bass HP to Front */
1990         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1991         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1992         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1993 /* Connect Line-Out side jack (SPDIF) to Side */
1994         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1995         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1996         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1997 /* Connect Mic jack to CLFE */
1998         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1999         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2000         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
2001 /* Connect Line-in jack to Surround */
2002         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2003         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2004         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
2005 /* Connect HP out jack to Front */
2006         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2007         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2008         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2009 /* Enable unsolicited event for HP jack and Line-out jack */
2010         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2011         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2012         {}
2013 };
2014
2015 static void alc_automute_amp(struct hda_codec *codec)
2016 {
2017         alc_automute_speaker(codec, 0);
2018 }
2019
2020 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
2021                                          unsigned int res)
2022 {
2023         if (codec->vendor_id == 0x10ec0880)
2024                 res >>= 28;
2025         else
2026                 res >>= 26;
2027         if (res == ALC880_HP_EVENT)
2028                 alc_automute_amp(codec);
2029 }
2030
2031 static void alc889_automute_setup(struct hda_codec *codec)
2032 {
2033         struct alc_spec *spec = codec->spec;
2034
2035         spec->autocfg.hp_pins[0] = 0x15;
2036         spec->autocfg.speaker_pins[0] = 0x14;
2037         spec->autocfg.speaker_pins[1] = 0x16;
2038         spec->autocfg.speaker_pins[2] = 0x17;
2039         spec->autocfg.speaker_pins[3] = 0x19;
2040         spec->autocfg.speaker_pins[4] = 0x1a;
2041 }
2042
2043 static void alc889_intel_init_hook(struct hda_codec *codec)
2044 {
2045         alc889_coef_init(codec);
2046         alc_automute_amp(codec);
2047 }
2048
2049 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
2050 {
2051         struct alc_spec *spec = codec->spec;
2052
2053         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
2054         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
2055         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
2056         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
2057 }
2058
2059 /*
2060  * ALC888 Acer Aspire 4930G model
2061  */
2062
2063 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
2064 /* Front Mic: set to PIN_IN (empty by default) */
2065         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2066 /* Unselect Front Mic by default in input mixer 3 */
2067         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2068 /* Enable unsolicited event for HP jack */
2069         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2070 /* Connect Internal HP to front */
2071         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2072         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2073         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2074 /* Connect HP out to front */
2075         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2076         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2077         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2078         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2079         { }
2080 };
2081
2082 /*
2083  * ALC888 Acer Aspire 6530G model
2084  */
2085
2086 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
2087 /* Route to built-in subwoofer as well as speakers */
2088         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2089         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2090         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2091         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2092 /* Bias voltage on for external mic port */
2093         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2094 /* Front Mic: set to PIN_IN (empty by default) */
2095         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2096 /* Unselect Front Mic by default in input mixer 3 */
2097         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2098 /* Enable unsolicited event for HP jack */
2099         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2100 /* Enable speaker output */
2101         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2102         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2103         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2104 /* Enable headphone output */
2105         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2106         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2107         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2108         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2109         { }
2110 };
2111
2112 /*
2113  *ALC888 Acer Aspire 7730G model
2114  */
2115
2116 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
2117 /* Bias voltage on for external mic port */
2118         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2119 /* Front Mic: set to PIN_IN (empty by default) */
2120         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2121 /* Unselect Front Mic by default in input mixer 3 */
2122         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2123 /* Enable unsolicited event for HP jack */
2124         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2125 /* Enable speaker output */
2126         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2127         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2128         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2129 /* Enable headphone output */
2130         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2131         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2132         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2133         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2134 /*Enable internal subwoofer */
2135         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2136         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2137         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
2138         {0x17, AC_VERB_SET_EAPD_BTLENABLE, 2},
2139         { }
2140 };
2141
2142 /*
2143  * ALC889 Acer Aspire 8930G model
2144  */
2145
2146 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
2147 /* Front Mic: set to PIN_IN (empty by default) */
2148         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2149 /* Unselect Front Mic by default in input mixer 3 */
2150         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2151 /* Enable unsolicited event for HP jack */
2152         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2153 /* Connect Internal Front to Front */
2154         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2155         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2156         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2157 /* Connect Internal Rear to Rear */
2158         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2159         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2160         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
2161 /* Connect Internal CLFE to CLFE */
2162         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2163         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2164         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
2165 /* Connect HP out to Front */
2166         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2167         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2168         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2169 /* Enable all DACs */
2170 /*  DAC DISABLE/MUTE 1? */
2171 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
2172         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
2173         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2174 /*  DAC DISABLE/MUTE 2? */
2175 /*  some bit here disables the other DACs. Init=0x4900 */
2176         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
2177         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2178 /* DMIC fix
2179  * This laptop has a stereo digital microphone. The mics are only 1cm apart
2180  * which makes the stereo useless. However, either the mic or the ALC889
2181  * makes the signal become a difference/sum signal instead of standard
2182  * stereo, which is annoying. So instead we flip this bit which makes the
2183  * codec replicate the sum signal to both channels, turning it into a
2184  * normal mono mic.
2185  */
2186 /*  DMIC_CONTROL? Init value = 0x0001 */
2187         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
2188         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
2189         { }
2190 };
2191
2192 static struct hda_input_mux alc888_2_capture_sources[2] = {
2193         /* Front mic only available on one ADC */
2194         {
2195                 .num_items = 4,
2196                 .items = {
2197                         { "Mic", 0x0 },
2198                         { "Line", 0x2 },
2199                         { "CD", 0x4 },
2200                         { "Front Mic", 0xb },
2201                 },
2202         },
2203         {
2204                 .num_items = 3,
2205                 .items = {
2206                         { "Mic", 0x0 },
2207                         { "Line", 0x2 },
2208                         { "CD", 0x4 },
2209                 },
2210         }
2211 };
2212
2213 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
2214         /* Interal mic only available on one ADC */
2215         {
2216                 .num_items = 5,
2217                 .items = {
2218                         { "Mic", 0x0 },
2219                         { "Line In", 0x2 },
2220                         { "CD", 0x4 },
2221                         { "Input Mix", 0xa },
2222                         { "Internal Mic", 0xb },
2223                 },
2224         },
2225         {
2226                 .num_items = 4,
2227                 .items = {
2228                         { "Mic", 0x0 },
2229                         { "Line In", 0x2 },
2230                         { "CD", 0x4 },
2231                         { "Input Mix", 0xa },
2232                 },
2233         }
2234 };
2235
2236 static struct hda_input_mux alc889_capture_sources[3] = {
2237         /* Digital mic only available on first "ADC" */
2238         {
2239                 .num_items = 5,
2240                 .items = {
2241                         { "Mic", 0x0 },
2242                         { "Line", 0x2 },
2243                         { "CD", 0x4 },
2244                         { "Front Mic", 0xb },
2245                         { "Input Mix", 0xa },
2246                 },
2247         },
2248         {
2249                 .num_items = 4,
2250                 .items = {
2251                         { "Mic", 0x0 },
2252                         { "Line", 0x2 },
2253                         { "CD", 0x4 },
2254                         { "Input Mix", 0xa },
2255                 },
2256         },
2257         {
2258                 .num_items = 4,
2259                 .items = {
2260                         { "Mic", 0x0 },
2261                         { "Line", 0x2 },
2262                         { "CD", 0x4 },
2263                         { "Input Mix", 0xa },
2264                 },
2265         }
2266 };
2267
2268 static struct snd_kcontrol_new alc888_base_mixer[] = {
2269         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2270         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2271         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2272         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2273         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2274                 HDA_OUTPUT),
2275         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2276         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2277         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2278         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2279         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2280         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2281         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2282         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2283         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2284         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2285         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2286         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2287         { } /* end */
2288 };
2289
2290 static struct snd_kcontrol_new alc888_acer_aspire_4930g_mixer[] = {
2291         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2292         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2293         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2294         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2295         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0f, 2, 0x0,
2296                 HDA_OUTPUT),
2297         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0f, 2, 2, HDA_INPUT),
2298         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0f, 1, 0x0, HDA_OUTPUT),
2299         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0f, 1, 2, HDA_INPUT),
2300         HDA_CODEC_VOLUME("Side Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
2301         HDA_BIND_MUTE("Side Playback Switch", 0x0e, 2, HDA_INPUT),
2302         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2303         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2304         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2305         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2306         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2307         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2308         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2309         { } /* end */
2310 };
2311
2312
2313 static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
2314         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2315         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2316         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2317         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2318         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2319                 HDA_OUTPUT),
2320         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2321         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2322         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2323         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2324         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2325         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2326         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2327         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2328         { } /* end */
2329 };
2330
2331
2332 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
2333 {
2334         struct alc_spec *spec = codec->spec;
2335
2336         spec->autocfg.hp_pins[0] = 0x15;
2337         spec->autocfg.speaker_pins[0] = 0x14;
2338         spec->autocfg.speaker_pins[1] = 0x16;
2339         spec->autocfg.speaker_pins[2] = 0x17;
2340 }
2341
2342 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
2343 {
2344         struct alc_spec *spec = codec->spec;
2345
2346         spec->autocfg.hp_pins[0] = 0x15;
2347         spec->autocfg.speaker_pins[0] = 0x14;
2348         spec->autocfg.speaker_pins[1] = 0x16;
2349         spec->autocfg.speaker_pins[2] = 0x17;
2350 }
2351
2352 static void alc888_acer_aspire_7730g_setup(struct hda_codec *codec)
2353 {
2354         struct alc_spec *spec = codec->spec;
2355
2356         spec->autocfg.hp_pins[0] = 0x15;
2357         spec->autocfg.speaker_pins[0] = 0x14;
2358         spec->autocfg.speaker_pins[1] = 0x16;
2359         spec->autocfg.speaker_pins[2] = 0x17;
2360 }
2361
2362 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
2363 {
2364         struct alc_spec *spec = codec->spec;
2365
2366         spec->autocfg.hp_pins[0] = 0x15;
2367         spec->autocfg.speaker_pins[0] = 0x14;
2368         spec->autocfg.speaker_pins[1] = 0x16;
2369         spec->autocfg.speaker_pins[2] = 0x1b;
2370 }
2371
2372 /*
2373  * ALC880 3-stack model
2374  *
2375  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
2376  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
2377  *                 F-Mic = 0x1b, HP = 0x19
2378  */
2379
2380 static hda_nid_t alc880_dac_nids[4] = {
2381         /* front, rear, clfe, rear_surr */
2382         0x02, 0x05, 0x04, 0x03
2383 };
2384
2385 static hda_nid_t alc880_adc_nids[3] = {
2386         /* ADC0-2 */
2387         0x07, 0x08, 0x09,
2388 };
2389
2390 /* The datasheet says the node 0x07 is connected from inputs,
2391  * but it shows zero connection in the real implementation on some devices.
2392  * Note: this is a 915GAV bug, fixed on 915GLV
2393  */
2394 static hda_nid_t alc880_adc_nids_alt[2] = {
2395         /* ADC1-2 */
2396         0x08, 0x09,
2397 };
2398
2399 #define ALC880_DIGOUT_NID       0x06
2400 #define ALC880_DIGIN_NID        0x0a
2401
2402 static struct hda_input_mux alc880_capture_source = {
2403         .num_items = 4,
2404         .items = {
2405                 { "Mic", 0x0 },
2406                 { "Front Mic", 0x3 },
2407                 { "Line", 0x2 },
2408                 { "CD", 0x4 },
2409         },
2410 };
2411
2412 /* channel source setting (2/6 channel selection for 3-stack) */
2413 /* 2ch mode */
2414 static struct hda_verb alc880_threestack_ch2_init[] = {
2415         /* set line-in to input, mute it */
2416         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2417         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2418         /* set mic-in to input vref 80%, mute it */
2419         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2420         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2421         { } /* end */
2422 };
2423
2424 /* 6ch mode */
2425 static struct hda_verb alc880_threestack_ch6_init[] = {
2426         /* set line-in to output, unmute it */
2427         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2428         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2429         /* set mic-in to output, unmute it */
2430         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2431         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2432         { } /* end */
2433 };
2434
2435 static struct hda_channel_mode alc880_threestack_modes[2] = {
2436         { 2, alc880_threestack_ch2_init },
2437         { 6, alc880_threestack_ch6_init },
2438 };
2439
2440 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
2441         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2442         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2443         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2444         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2445         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2446         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2447         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2448         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2449         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2450         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2451         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2452         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2453         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2454         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2455         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
2456         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
2457         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
2458         {
2459                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2460                 .name = "Channel Mode",
2461                 .info = alc_ch_mode_info,
2462                 .get = alc_ch_mode_get,
2463                 .put = alc_ch_mode_put,
2464         },
2465         { } /* end */
2466 };
2467
2468 /* capture mixer elements */
2469 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
2470                             struct snd_ctl_elem_info *uinfo)
2471 {
2472         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2473         struct alc_spec *spec = codec->spec;
2474         int err;
2475
2476         mutex_lock(&codec->control_mutex);
2477         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2478                                                       HDA_INPUT);
2479         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
2480         mutex_unlock(&codec->control_mutex);
2481         return err;
2482 }
2483
2484 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2485                            unsigned int size, unsigned int __user *tlv)
2486 {
2487         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2488         struct alc_spec *spec = codec->spec;
2489         int err;
2490
2491         mutex_lock(&codec->control_mutex);
2492         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2493                                                       HDA_INPUT);
2494         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
2495         mutex_unlock(&codec->control_mutex);
2496         return err;
2497 }
2498
2499 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
2500                              struct snd_ctl_elem_value *ucontrol);
2501
2502 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
2503                                  struct snd_ctl_elem_value *ucontrol,
2504                                  getput_call_t func)
2505 {
2506         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2507         struct alc_spec *spec = codec->spec;
2508         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2509         int err;
2510
2511         mutex_lock(&codec->control_mutex);
2512         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
2513                                                       3, 0, HDA_INPUT);
2514         err = func(kcontrol, ucontrol);
2515         mutex_unlock(&codec->control_mutex);
2516         return err;
2517 }
2518
2519 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
2520                            struct snd_ctl_elem_value *ucontrol)
2521 {
2522         return alc_cap_getput_caller(kcontrol, ucontrol,
2523                                      snd_hda_mixer_amp_volume_get);
2524 }
2525
2526 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2527                            struct snd_ctl_elem_value *ucontrol)
2528 {
2529         return alc_cap_getput_caller(kcontrol, ucontrol,
2530                                      snd_hda_mixer_amp_volume_put);
2531 }
2532
2533 /* capture mixer elements */
2534 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2535
2536 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2537                           struct snd_ctl_elem_value *ucontrol)
2538 {
2539         return alc_cap_getput_caller(kcontrol, ucontrol,
2540                                      snd_hda_mixer_amp_switch_get);
2541 }
2542
2543 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2544                           struct snd_ctl_elem_value *ucontrol)
2545 {
2546         return alc_cap_getput_caller(kcontrol, ucontrol,
2547                                      snd_hda_mixer_amp_switch_put);
2548 }
2549
2550 #define _DEFINE_CAPMIX(num) \
2551         { \
2552                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2553                 .name = "Capture Switch", \
2554                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2555                 .count = num, \
2556                 .info = alc_cap_sw_info, \
2557                 .get = alc_cap_sw_get, \
2558                 .put = alc_cap_sw_put, \
2559         }, \
2560         { \
2561                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2562                 .name = "Capture Volume", \
2563                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2564                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2565                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2566                 .count = num, \
2567                 .info = alc_cap_vol_info, \
2568                 .get = alc_cap_vol_get, \
2569                 .put = alc_cap_vol_put, \
2570                 .tlv = { .c = alc_cap_vol_tlv }, \
2571         }
2572
2573 #define _DEFINE_CAPSRC(num) \
2574         { \
2575                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2576                 /* .name = "Capture Source", */ \
2577                 .name = "Input Source", \
2578                 .count = num, \
2579                 .info = alc_mux_enum_info, \
2580                 .get = alc_mux_enum_get, \
2581                 .put = alc_mux_enum_put, \
2582         }
2583
2584 #define DEFINE_CAPMIX(num) \
2585 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2586         _DEFINE_CAPMIX(num),                                  \
2587         _DEFINE_CAPSRC(num),                                  \
2588         { } /* end */                                         \
2589 }
2590
2591 #define DEFINE_CAPMIX_NOSRC(num) \
2592 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2593         _DEFINE_CAPMIX(num),                                        \
2594         { } /* end */                                               \
2595 }
2596
2597 /* up to three ADCs */
2598 DEFINE_CAPMIX(1);
2599 DEFINE_CAPMIX(2);
2600 DEFINE_CAPMIX(3);
2601 DEFINE_CAPMIX_NOSRC(1);
2602 DEFINE_CAPMIX_NOSRC(2);
2603 DEFINE_CAPMIX_NOSRC(3);
2604
2605 /*
2606  * ALC880 5-stack model
2607  *
2608  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2609  *      Side = 0x02 (0xd)
2610  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2611  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2612  */
2613
2614 /* additional mixers to alc880_three_stack_mixer */
2615 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2616         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2617         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2618         { } /* end */
2619 };
2620
2621 /* channel source setting (6/8 channel selection for 5-stack) */
2622 /* 6ch mode */
2623 static struct hda_verb alc880_fivestack_ch6_init[] = {
2624         /* set line-in to input, mute it */
2625         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2626         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2627         { } /* end */
2628 };
2629
2630 /* 8ch mode */
2631 static struct hda_verb alc880_fivestack_ch8_init[] = {
2632         /* set line-in to output, unmute it */
2633         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2634         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2635         { } /* end */
2636 };
2637
2638 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2639         { 6, alc880_fivestack_ch6_init },
2640         { 8, alc880_fivestack_ch8_init },
2641 };
2642
2643
2644 /*
2645  * ALC880 6-stack model
2646  *
2647  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2648  *      Side = 0x05 (0x0f)
2649  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2650  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2651  */
2652
2653 static hda_nid_t alc880_6st_dac_nids[4] = {
2654         /* front, rear, clfe, rear_surr */
2655         0x02, 0x03, 0x04, 0x05
2656 };
2657
2658 static struct hda_input_mux alc880_6stack_capture_source = {
2659         .num_items = 4,
2660         .items = {
2661                 { "Mic", 0x0 },
2662                 { "Front Mic", 0x1 },
2663                 { "Line", 0x2 },
2664                 { "CD", 0x4 },
2665         },
2666 };
2667
2668 /* fixed 8-channels */
2669 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2670         { 8, NULL },
2671 };
2672
2673 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2674         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2675         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2676         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2677         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2678         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2679         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2680         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2681         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2682         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2683         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2684         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2685         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2686         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2687         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2688         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2689         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2690         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2691         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2692         {
2693                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2694                 .name = "Channel Mode",
2695                 .info = alc_ch_mode_info,
2696                 .get = alc_ch_mode_get,
2697                 .put = alc_ch_mode_put,
2698         },
2699         { } /* end */
2700 };
2701
2702
2703 /*
2704  * ALC880 W810 model
2705  *
2706  * W810 has rear IO for:
2707  * Front (DAC 02)
2708  * Surround (DAC 03)
2709  * Center/LFE (DAC 04)
2710  * Digital out (06)
2711  *
2712  * The system also has a pair of internal speakers, and a headphone jack.
2713  * These are both connected to Line2 on the codec, hence to DAC 02.
2714  *
2715  * There is a variable resistor to control the speaker or headphone
2716  * volume. This is a hardware-only device without a software API.
2717  *
2718  * Plugging headphones in will disable the internal speakers. This is
2719  * implemented in hardware, not via the driver using jack sense. In
2720  * a similar fashion, plugging into the rear socket marked "front" will
2721  * disable both the speakers and headphones.
2722  *
2723  * For input, there's a microphone jack, and an "audio in" jack.
2724  * These may not do anything useful with this driver yet, because I
2725  * haven't setup any initialization verbs for these yet...
2726  */
2727
2728 static hda_nid_t alc880_w810_dac_nids[3] = {
2729         /* front, rear/surround, clfe */
2730         0x02, 0x03, 0x04
2731 };
2732
2733 /* fixed 6 channels */
2734 static struct hda_channel_mode alc880_w810_modes[1] = {
2735         { 6, NULL }
2736 };
2737
2738 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2739 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2740         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2741         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2742         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2743         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2744         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2745         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2746         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2747         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2748         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2749         { } /* end */
2750 };
2751
2752
2753 /*
2754  * Z710V model
2755  *
2756  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2757  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2758  *                 Line = 0x1a
2759  */
2760
2761 static hda_nid_t alc880_z71v_dac_nids[1] = {
2762         0x02
2763 };
2764 #define ALC880_Z71V_HP_DAC      0x03
2765
2766 /* fixed 2 channels */
2767 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2768         { 2, NULL }
2769 };
2770
2771 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2772         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2773         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2774         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2775         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2776         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2777         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2778         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2779         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2780         { } /* end */
2781 };
2782
2783
2784 /*
2785  * ALC880 F1734 model
2786  *
2787  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2788  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2789  */
2790
2791 static hda_nid_t alc880_f1734_dac_nids[1] = {
2792         0x03
2793 };
2794 #define ALC880_F1734_HP_DAC     0x02
2795
2796 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2797         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2798         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2799         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2800         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2801         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2802         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2803         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2804         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2805         { } /* end */
2806 };
2807
2808 static struct hda_input_mux alc880_f1734_capture_source = {
2809         .num_items = 2,
2810         .items = {
2811                 { "Mic", 0x1 },
2812                 { "CD", 0x4 },
2813         },
2814 };
2815
2816
2817 /*
2818  * ALC880 ASUS model
2819  *
2820  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2821  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2822  *  Mic = 0x18, Line = 0x1a
2823  */
2824
2825 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2826 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2827
2828 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2829         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2830         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2831         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2832         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2833         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2834         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2835         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2836         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2837         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2838         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2839         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2840         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2841         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2842         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2843         {
2844                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2845                 .name = "Channel Mode",
2846                 .info = alc_ch_mode_info,
2847                 .get = alc_ch_mode_get,
2848                 .put = alc_ch_mode_put,
2849         },
2850         { } /* end */
2851 };
2852
2853 /*
2854  * ALC880 ASUS W1V model
2855  *
2856  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2857  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2858  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2859  */
2860
2861 /* additional mixers to alc880_asus_mixer */
2862 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2863         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2864         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2865         { } /* end */
2866 };
2867
2868 /* TCL S700 */
2869 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2870         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2871         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2872         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2873         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2874         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2875         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2876         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2877         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2878         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2879         { } /* end */
2880 };
2881
2882 /* Uniwill */
2883 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2884         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2885         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2886         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2887         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2888         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2889         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2890         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2891         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2892         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2893         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2894         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2895         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2896         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2897         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2898         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2899         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2900         {
2901                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2902                 .name = "Channel Mode",
2903                 .info = alc_ch_mode_info,
2904                 .get = alc_ch_mode_get,
2905                 .put = alc_ch_mode_put,
2906         },
2907         { } /* end */
2908 };
2909
2910 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2911         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2912         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2913         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2914         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2915         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2916         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2917         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2918         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2919         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2920         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2921         { } /* end */
2922 };
2923
2924 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2925         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2926         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2927         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2928         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2929         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2930         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2931         { } /* end */
2932 };
2933
2934 /*
2935  * virtual master controls
2936  */
2937
2938 /*
2939  * slave controls for virtual master
2940  */
2941 static const char * const alc_slave_vols[] = {
2942         "Front Playback Volume",
2943         "Surround Playback Volume",
2944         "Center Playback Volume",
2945         "LFE Playback Volume",
2946         "Side Playback Volume",
2947         "Headphone Playback Volume",
2948         "Speaker Playback Volume",
2949         "Mono Playback Volume",
2950         "Line-Out Playback Volume",
2951         "PCM Playback Volume",
2952         NULL,
2953 };
2954
2955 static const char * const alc_slave_sws[] = {
2956         "Front Playback Switch",
2957         "Surround Playback Switch",
2958         "Center Playback Switch",
2959         "LFE Playback Switch",
2960         "Side Playback Switch",
2961         "Headphone Playback Switch",
2962         "Speaker Playback Switch",
2963         "Mono Playback Switch",
2964         "IEC958 Playback Switch",
2965         "Line-Out Playback Switch",
2966         "PCM Playback Switch",
2967         NULL,
2968 };
2969
2970 /*
2971  * build control elements
2972  */
2973
2974 #define NID_MAPPING             (-1)
2975
2976 #define SUBDEV_SPEAKER_         (0 << 6)
2977 #define SUBDEV_HP_              (1 << 6)
2978 #define SUBDEV_LINE_            (2 << 6)
2979 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
2980 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
2981 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
2982
2983 static void alc_free_kctls(struct hda_codec *codec);
2984
2985 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2986 /* additional beep mixers; the actual parameters are overwritten at build */
2987 static struct snd_kcontrol_new alc_beep_mixer[] = {
2988         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2989         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2990         { } /* end */
2991 };
2992 #endif
2993
2994 static int alc_build_controls(struct hda_codec *codec)
2995 {
2996         struct alc_spec *spec = codec->spec;
2997         struct snd_kcontrol *kctl = NULL;
2998         struct snd_kcontrol_new *knew;
2999         int i, j, err;
3000         unsigned int u;
3001         hda_nid_t nid;
3002
3003         for (i = 0; i < spec->num_mixers; i++) {
3004                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
3005                 if (err < 0)
3006                         return err;
3007         }
3008         if (spec->cap_mixer) {
3009                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
3010                 if (err < 0)
3011                         return err;
3012         }
3013         if (spec->multiout.dig_out_nid) {
3014                 err = snd_hda_create_spdif_out_ctls(codec,
3015                                                     spec->multiout.dig_out_nid);
3016                 if (err < 0)
3017                         return err;
3018                 if (!spec->no_analog) {
3019                         err = snd_hda_create_spdif_share_sw(codec,
3020                                                             &spec->multiout);
3021                         if (err < 0)
3022                                 return err;
3023                         spec->multiout.share_spdif = 1;
3024                 }
3025         }
3026         if (spec->dig_in_nid) {
3027                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
3028                 if (err < 0)
3029                         return err;
3030         }
3031
3032 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3033         /* create beep controls if needed */
3034         if (spec->beep_amp) {
3035                 struct snd_kcontrol_new *knew;
3036                 for (knew = alc_beep_mixer; knew->name; knew++) {
3037                         struct snd_kcontrol *kctl;
3038                         kctl = snd_ctl_new1(knew, codec);
3039                         if (!kctl)
3040                                 return -ENOMEM;
3041                         kctl->private_value = spec->beep_amp;
3042                         err = snd_hda_ctl_add(codec, 0, kctl);
3043                         if (err < 0)
3044                                 return err;
3045                 }
3046         }
3047 #endif
3048
3049         /* if we have no master control, let's create it */
3050         if (!spec->no_analog &&
3051             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
3052                 unsigned int vmaster_tlv[4];
3053                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
3054                                         HDA_OUTPUT, vmaster_tlv);
3055                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
3056                                           vmaster_tlv, alc_slave_vols);
3057                 if (err < 0)
3058                         return err;
3059         }
3060         if (!spec->no_analog &&
3061             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
3062                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
3063                                           NULL, alc_slave_sws);
3064                 if (err < 0)
3065                         return err;
3066         }
3067
3068         /* assign Capture Source enums to NID */
3069         if (spec->capsrc_nids || spec->adc_nids) {
3070                 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
3071                 if (!kctl)
3072                         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
3073                 for (i = 0; kctl && i < kctl->count; i++) {
3074                         hda_nid_t *nids = spec->capsrc_nids;
3075                         if (!nids)
3076                                 nids = spec->adc_nids;
3077                         err = snd_hda_add_nid(codec, kctl, i, nids[i]);
3078                         if (err < 0)
3079                                 return err;
3080                 }
3081         }
3082         if (spec->cap_mixer) {
3083                 const char *kname = kctl ? kctl->id.name : NULL;
3084                 for (knew = spec->cap_mixer; knew->name; knew++) {
3085                         if (kname && strcmp(knew->name, kname) == 0)
3086                                 continue;
3087                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3088                         for (i = 0; kctl && i < kctl->count; i++) {
3089                                 err = snd_hda_add_nid(codec, kctl, i,
3090                                                       spec->adc_nids[i]);
3091                                 if (err < 0)
3092                                         return err;
3093                         }
3094                 }
3095         }
3096
3097         /* other nid->control mapping */
3098         for (i = 0; i < spec->num_mixers; i++) {
3099                 for (knew = spec->mixers[i]; knew->name; knew++) {
3100                         if (knew->iface != NID_MAPPING)
3101                                 continue;
3102                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3103                         if (kctl == NULL)
3104                                 continue;
3105                         u = knew->subdevice;
3106                         for (j = 0; j < 4; j++, u >>= 8) {
3107                                 nid = u & 0x3f;
3108                                 if (nid == 0)
3109                                         continue;
3110                                 switch (u & 0xc0) {
3111                                 case SUBDEV_SPEAKER_:
3112                                         nid = spec->autocfg.speaker_pins[nid];
3113                                         break;
3114                                 case SUBDEV_LINE_:
3115                                         nid = spec->autocfg.line_out_pins[nid];
3116                                         break;
3117                                 case SUBDEV_HP_:
3118                                         nid = spec->autocfg.hp_pins[nid];
3119                                         break;
3120                                 default:
3121                                         continue;
3122                                 }
3123                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
3124                                 if (err < 0)
3125                                         return err;
3126                         }
3127                         u = knew->private_value;
3128                         for (j = 0; j < 4; j++, u >>= 8) {
3129                                 nid = u & 0xff;
3130                                 if (nid == 0)
3131                                         continue;
3132                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
3133                                 if (err < 0)
3134                                         return err;
3135                         }
3136                 }
3137         }
3138
3139         alc_free_kctls(codec); /* no longer needed */
3140
3141         return 0;
3142 }
3143
3144
3145 /*
3146  * initialize the codec volumes, etc
3147  */
3148
3149 /*
3150  * generic initialization of ADC, input mixers and output mixers
3151  */
3152 static struct hda_verb alc880_volume_init_verbs[] = {
3153         /*
3154          * Unmute ADC0-2 and set the default input to mic-in
3155          */
3156         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3157         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3158         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3159         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3160         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3161         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3162
3163         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3164          * mixer widget
3165          * Note: PASD motherboards uses the Line In 2 as the input for front
3166          * panel mic (mic 2)
3167          */
3168         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
3169         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3170         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3171         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3172         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3173         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3174         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3175         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3176
3177         /*
3178          * Set up output mixers (0x0c - 0x0f)
3179          */
3180         /* set vol=0 to output mixers */
3181         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3182         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3183         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3184         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3185         /* set up input amps for analog loopback */
3186         /* Amp Indices: DAC = 0, mixer = 1 */
3187         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3188         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3189         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3190         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3191         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3192         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3193         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3194         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3195
3196         { }
3197 };
3198
3199 /*
3200  * 3-stack pin configuration:
3201  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
3202  */
3203 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
3204         /*
3205          * preset connection lists of input pins
3206          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3207          */
3208         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3209         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3210         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3211
3212         /*
3213          * Set pin mode and muting
3214          */
3215         /* set front pin widgets 0x14 for output */
3216         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3217         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3218         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3219         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3220         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3221         /* Mic2 (as headphone out) for HP output */
3222         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3223         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3224         /* Line In pin widget for input */
3225         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3226         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3227         /* Line2 (as front mic) pin widget for input and vref at 80% */
3228         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3229         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3230         /* CD pin widget for input */
3231         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3232
3233         { }
3234 };
3235
3236 /*
3237  * 5-stack pin configuration:
3238  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
3239  * line-in/side = 0x1a, f-mic = 0x1b
3240  */
3241 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
3242         /*
3243          * preset connection lists of input pins
3244          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3245          */
3246         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3247         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
3248
3249         /*
3250          * Set pin mode and muting
3251          */
3252         /* set pin widgets 0x14-0x17 for output */
3253         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3254         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3255         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3256         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3257         /* unmute pins for output (no gain on this amp) */
3258         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3259         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3260         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3261         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3262
3263         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3264         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3265         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3266         /* Mic2 (as headphone out) for HP output */
3267         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3268         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3269         /* Line In pin widget for input */
3270         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3271         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3272         /* Line2 (as front mic) pin widget for input and vref at 80% */
3273         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3274         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3275         /* CD pin widget for input */
3276         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3277
3278         { }
3279 };
3280
3281 /*
3282  * W810 pin configuration:
3283  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
3284  */
3285 static struct hda_verb alc880_pin_w810_init_verbs[] = {
3286         /* hphone/speaker input selector: front DAC */
3287         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
3288
3289         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3290         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3291         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3292         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3293         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3294         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3295
3296         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3297         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3298
3299         { }
3300 };
3301
3302 /*
3303  * Z71V pin configuration:
3304  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
3305  */
3306 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
3307         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3308         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3309         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3310         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3311
3312         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3313         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3314         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3315         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3316
3317         { }
3318 };
3319
3320 /*
3321  * 6-stack pin configuration:
3322  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
3323  * f-mic = 0x19, line = 0x1a, HP = 0x1b
3324  */
3325 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
3326         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3327
3328         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3329         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3330         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3331         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3332         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3333         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3334         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3335         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3336
3337         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3338         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3339         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3340         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3341         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3342         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3343         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3344         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3345         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3346
3347         { }
3348 };
3349
3350 /*
3351  * Uniwill pin configuration:
3352  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
3353  * line = 0x1a
3354  */
3355 static struct hda_verb alc880_uniwill_init_verbs[] = {
3356         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3357
3358         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3359         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3360         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3361         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3362         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3363         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3364         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3365         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3366         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3367         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3368         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3369         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3370         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3371         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3372
3373         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3374         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3375         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3376         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3377         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3378         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3379         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
3380         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
3381         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3382
3383         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3384         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
3385
3386         { }
3387 };
3388
3389 /*
3390 * Uniwill P53
3391 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
3392  */
3393 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
3394         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3395
3396         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3397         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3398         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3399         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3400         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3401         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3402         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3403         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3404         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3405         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3406         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3407         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3408
3409         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3410         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3411         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3412         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3413         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3414         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3415
3416         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3417         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
3418
3419         { }
3420 };
3421
3422 static struct hda_verb alc880_beep_init_verbs[] = {
3423         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
3424         { }
3425 };
3426
3427 /* auto-toggle front mic */
3428 static void alc88x_simple_mic_automute(struct hda_codec *codec)
3429 {
3430         unsigned int present;
3431         unsigned char bits;
3432
3433         present = snd_hda_jack_detect(codec, 0x18);
3434         bits = present ? HDA_AMP_MUTE : 0;
3435         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
3436 }
3437
3438 static void alc880_uniwill_setup(struct hda_codec *codec)
3439 {
3440         struct alc_spec *spec = codec->spec;
3441
3442         spec->autocfg.hp_pins[0] = 0x14;
3443         spec->autocfg.speaker_pins[0] = 0x15;
3444         spec->autocfg.speaker_pins[0] = 0x16;
3445 }
3446
3447 static void alc880_uniwill_init_hook(struct hda_codec *codec)
3448 {
3449         alc_automute_amp(codec);
3450         alc88x_simple_mic_automute(codec);
3451 }
3452
3453 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
3454                                        unsigned int res)
3455 {
3456         /* Looks like the unsol event is incompatible with the standard
3457          * definition.  4bit tag is placed at 28 bit!
3458          */
3459         switch (res >> 28) {
3460         case ALC880_MIC_EVENT:
3461                 alc88x_simple_mic_automute(codec);
3462                 break;
3463         default:
3464                 alc_automute_amp_unsol_event(codec, res);
3465                 break;
3466         }
3467 }
3468
3469 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
3470 {
3471         struct alc_spec *spec = codec->spec;
3472
3473         spec->autocfg.hp_pins[0] = 0x14;
3474         spec->autocfg.speaker_pins[0] = 0x15;
3475 }
3476
3477 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
3478 {
3479         unsigned int present;
3480
3481         present = snd_hda_codec_read(codec, 0x21, 0,
3482                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
3483         present &= HDA_AMP_VOLMASK;
3484         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
3485                                  HDA_AMP_VOLMASK, present);
3486         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
3487                                  HDA_AMP_VOLMASK, present);
3488 }
3489
3490 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
3491                                            unsigned int res)
3492 {
3493         /* Looks like the unsol event is incompatible with the standard
3494          * definition.  4bit tag is placed at 28 bit!
3495          */
3496         if ((res >> 28) == ALC880_DCVOL_EVENT)
3497                 alc880_uniwill_p53_dcvol_automute(codec);
3498         else
3499                 alc_automute_amp_unsol_event(codec, res);
3500 }
3501
3502 /*
3503  * F1734 pin configuration:
3504  * HP = 0x14, speaker-out = 0x15, mic = 0x18
3505  */
3506 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
3507         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
3508         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3509         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3510         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3511         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3512
3513         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3514         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3515         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3516         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3517
3518         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3519         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3520         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3521         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3522         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3523         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3524         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3525         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3526         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3527
3528         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3529         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3530
3531         { }
3532 };
3533
3534 /*
3535  * ASUS pin configuration:
3536  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3537  */
3538 static struct hda_verb alc880_pin_asus_init_verbs[] = {
3539         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3540         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3541         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3542         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3543
3544         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3545         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3546         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3547         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3548         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3549         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3550         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3551         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3552
3553         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3554         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3555         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3556         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3557         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3558         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3559         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3560         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3561         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3562
3563         { }
3564 };
3565
3566 /* Enable GPIO mask and set output */
3567 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
3568 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
3569 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
3570
3571 /* Clevo m520g init */
3572 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3573         /* headphone output */
3574         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3575         /* line-out */
3576         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3577         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3578         /* Line-in */
3579         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3580         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3581         /* CD */
3582         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3583         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3584         /* Mic1 (rear panel) */
3585         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3586         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3587         /* Mic2 (front panel) */
3588         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3589         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3590         /* headphone */
3591         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3592         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3593         /* change to EAPD mode */
3594         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3595         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3596
3597         { }
3598 };
3599
3600 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3601         /* change to EAPD mode */
3602         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3603         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3604
3605         /* Headphone output */
3606         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3607         /* Front output*/
3608         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3609         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3610
3611         /* Line In pin widget for input */
3612         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3613         /* CD pin widget for input */
3614         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3615         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3616         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3617
3618         /* change to EAPD mode */
3619         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3620         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3621
3622         { }
3623 };
3624
3625 /*
3626  * LG m1 express dual
3627  *
3628  * Pin assignment:
3629  *   Rear Line-In/Out (blue): 0x14
3630  *   Build-in Mic-In: 0x15
3631  *   Speaker-out: 0x17
3632  *   HP-Out (green): 0x1b
3633  *   Mic-In/Out (red): 0x19
3634  *   SPDIF-Out: 0x1e
3635  */
3636
3637 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3638 static hda_nid_t alc880_lg_dac_nids[3] = {
3639         0x05, 0x02, 0x03
3640 };
3641
3642 /* seems analog CD is not working */
3643 static struct hda_input_mux alc880_lg_capture_source = {
3644         .num_items = 3,
3645         .items = {
3646                 { "Mic", 0x1 },
3647                 { "Line", 0x5 },
3648                 { "Internal Mic", 0x6 },
3649         },
3650 };
3651
3652 /* 2,4,6 channel modes */
3653 static struct hda_verb alc880_lg_ch2_init[] = {
3654         /* set line-in and mic-in to input */
3655         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3656         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3657         { }
3658 };
3659
3660 static struct hda_verb alc880_lg_ch4_init[] = {
3661         /* set line-in to out and mic-in to input */
3662         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3663         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3664         { }
3665 };
3666
3667 static struct hda_verb alc880_lg_ch6_init[] = {
3668         /* set line-in and mic-in to output */
3669         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3670         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3671         { }
3672 };
3673
3674 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3675         { 2, alc880_lg_ch2_init },
3676         { 4, alc880_lg_ch4_init },
3677         { 6, alc880_lg_ch6_init },
3678 };
3679
3680 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3681         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3682         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3683         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3684         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3685         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3686         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3687         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3688         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3689         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3690         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3691         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3692         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3693         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3694         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3695         {
3696                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3697                 .name = "Channel Mode",
3698                 .info = alc_ch_mode_info,
3699                 .get = alc_ch_mode_get,
3700                 .put = alc_ch_mode_put,
3701         },
3702         { } /* end */
3703 };
3704
3705 static struct hda_verb alc880_lg_init_verbs[] = {
3706         /* set capture source to mic-in */
3707         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3708         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3709         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3710         /* mute all amp mixer inputs */
3711         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3712         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3713         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3714         /* line-in to input */
3715         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3716         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3717         /* built-in mic */
3718         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3719         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3720         /* speaker-out */
3721         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3722         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3723         /* mic-in to input */
3724         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3725         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3726         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3727         /* HP-out */
3728         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3729         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3730         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3731         /* jack sense */
3732         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3733         { }
3734 };
3735
3736 /* toggle speaker-output according to the hp-jack state */
3737 static void alc880_lg_setup(struct hda_codec *codec)
3738 {
3739         struct alc_spec *spec = codec->spec;
3740
3741         spec->autocfg.hp_pins[0] = 0x1b;
3742         spec->autocfg.speaker_pins[0] = 0x17;
3743 }
3744
3745 /*
3746  * LG LW20
3747  *
3748  * Pin assignment:
3749  *   Speaker-out: 0x14
3750  *   Mic-In: 0x18
3751  *   Built-in Mic-In: 0x19
3752  *   Line-In: 0x1b
3753  *   HP-Out: 0x1a
3754  *   SPDIF-Out: 0x1e
3755  */
3756
3757 static struct hda_input_mux alc880_lg_lw_capture_source = {
3758         .num_items = 3,
3759         .items = {
3760                 { "Mic", 0x0 },
3761                 { "Internal Mic", 0x1 },
3762                 { "Line In", 0x2 },
3763         },
3764 };
3765
3766 #define alc880_lg_lw_modes alc880_threestack_modes
3767
3768 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3769         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3770         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3771         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3772         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3773         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3774         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3775         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3776         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3777         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3778         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3779         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3780         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3781         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3782         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3783         {
3784                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3785                 .name = "Channel Mode",
3786                 .info = alc_ch_mode_info,
3787                 .get = alc_ch_mode_get,
3788                 .put = alc_ch_mode_put,
3789         },
3790         { } /* end */
3791 };
3792
3793 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3794         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3795         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3796         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3797
3798         /* set capture source to mic-in */
3799         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3800         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3801         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3802         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3803         /* speaker-out */
3804         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3805         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3806         /* HP-out */
3807         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3808         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3809         /* mic-in to input */
3810         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3811         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3812         /* built-in mic */
3813         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3814         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3815         /* jack sense */
3816         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3817         { }
3818 };
3819
3820 /* toggle speaker-output according to the hp-jack state */
3821 static void alc880_lg_lw_setup(struct hda_codec *codec)
3822 {
3823         struct alc_spec *spec = codec->spec;
3824
3825         spec->autocfg.hp_pins[0] = 0x1b;
3826         spec->autocfg.speaker_pins[0] = 0x14;
3827 }
3828
3829 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3830         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3831         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3832         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3833         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3834         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3835         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3836         { } /* end */
3837 };
3838
3839 static struct hda_input_mux alc880_medion_rim_capture_source = {
3840         .num_items = 2,
3841         .items = {
3842                 { "Mic", 0x0 },
3843                 { "Internal Mic", 0x1 },
3844         },
3845 };
3846
3847 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3848         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3849
3850         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3851         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3852
3853         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3854         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3855         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3856         /* Mic2 (as headphone out) for HP output */
3857         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3858         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3859         /* Internal Speaker */
3860         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3861         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3862
3863         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3864         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3865
3866         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3867         { }
3868 };
3869
3870 /* toggle speaker-output according to the hp-jack state */
3871 static void alc880_medion_rim_automute(struct hda_codec *codec)
3872 {
3873         struct alc_spec *spec = codec->spec;
3874         alc_automute_amp(codec);
3875         /* toggle EAPD */
3876         if (spec->jack_present)
3877                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3878         else
3879                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3880 }
3881
3882 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3883                                           unsigned int res)
3884 {
3885         /* Looks like the unsol event is incompatible with the standard
3886          * definition.  4bit tag is placed at 28 bit!
3887          */
3888         if ((res >> 28) == ALC880_HP_EVENT)
3889                 alc880_medion_rim_automute(codec);
3890 }
3891
3892 static void alc880_medion_rim_setup(struct hda_codec *codec)
3893 {
3894         struct alc_spec *spec = codec->spec;
3895
3896         spec->autocfg.hp_pins[0] = 0x14;
3897         spec->autocfg.speaker_pins[0] = 0x1b;
3898 }
3899
3900 #ifdef CONFIG_SND_HDA_POWER_SAVE
3901 static struct hda_amp_list alc880_loopbacks[] = {
3902         { 0x0b, HDA_INPUT, 0 },
3903         { 0x0b, HDA_INPUT, 1 },
3904         { 0x0b, HDA_INPUT, 2 },
3905         { 0x0b, HDA_INPUT, 3 },
3906         { 0x0b, HDA_INPUT, 4 },
3907         { } /* end */
3908 };
3909
3910 static struct hda_amp_list alc880_lg_loopbacks[] = {
3911         { 0x0b, HDA_INPUT, 1 },
3912         { 0x0b, HDA_INPUT, 6 },
3913         { 0x0b, HDA_INPUT, 7 },
3914         { } /* end */
3915 };
3916 #endif
3917
3918 /*
3919  * Common callbacks
3920  */
3921
3922 static int alc_init(struct hda_codec *codec)
3923 {
3924         struct alc_spec *spec = codec->spec;
3925         unsigned int i;
3926
3927         alc_fix_pll(codec);
3928         alc_auto_init_amp(codec, spec->init_amp);
3929
3930         for (i = 0; i < spec->num_init_verbs; i++)
3931                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3932
3933         if (spec->init_hook)
3934                 spec->init_hook(codec);
3935
3936         alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
3937
3938         hda_call_check_power_status(codec, 0x01);
3939         return 0;
3940 }
3941
3942 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3943 {
3944         struct alc_spec *spec = codec->spec;
3945
3946         if (spec->unsol_event)
3947                 spec->unsol_event(codec, res);
3948 }
3949
3950 #ifdef CONFIG_SND_HDA_POWER_SAVE
3951 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3952 {
3953         struct alc_spec *spec = codec->spec;
3954         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3955 }
3956 #endif
3957
3958 /*
3959  * Analog playback callbacks
3960  */
3961 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3962                                     struct hda_codec *codec,
3963                                     struct snd_pcm_substream *substream)
3964 {
3965         struct alc_spec *spec = codec->spec;
3966         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3967                                              hinfo);
3968 }
3969
3970 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3971                                        struct hda_codec *codec,
3972                                        unsigned int stream_tag,
3973                                        unsigned int format,
3974                                        struct snd_pcm_substream *substream)
3975 {
3976         struct alc_spec *spec = codec->spec;
3977         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3978                                                 stream_tag, format, substream);
3979 }
3980
3981 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3982                                        struct hda_codec *codec,
3983                                        struct snd_pcm_substream *substream)
3984 {
3985         struct alc_spec *spec = codec->spec;
3986         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3987 }
3988
3989 /*
3990  * Digital out
3991  */
3992 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3993                                         struct hda_codec *codec,
3994                                         struct snd_pcm_substream *substream)
3995 {
3996         struct alc_spec *spec = codec->spec;
3997         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3998 }
3999
4000 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4001                                            struct hda_codec *codec,
4002                                            unsigned int stream_tag,
4003                                            unsigned int format,
4004                                            struct snd_pcm_substream *substream)
4005 {
4006         struct alc_spec *spec = codec->spec;
4007         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
4008                                              stream_tag, format, substream);
4009 }
4010
4011 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4012                                            struct hda_codec *codec,
4013                                            struct snd_pcm_substream *substream)
4014 {
4015         struct alc_spec *spec = codec->spec;
4016         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
4017 }
4018
4019 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
4020                                          struct hda_codec *codec,
4021                                          struct snd_pcm_substream *substream)
4022 {
4023         struct alc_spec *spec = codec->spec;
4024         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
4025 }
4026
4027 /*
4028  * Analog capture
4029  */
4030 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4031                                       struct hda_codec *codec,
4032                                       unsigned int stream_tag,
4033                                       unsigned int format,
4034                                       struct snd_pcm_substream *substream)
4035 {
4036         struct alc_spec *spec = codec->spec;
4037
4038         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
4039                                    stream_tag, 0, format);
4040         return 0;
4041 }
4042
4043 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4044                                       struct hda_codec *codec,
4045                                       struct snd_pcm_substream *substream)
4046 {
4047         struct alc_spec *spec = codec->spec;
4048
4049         snd_hda_codec_cleanup_stream(codec,
4050                                      spec->adc_nids[substream->number + 1]);
4051         return 0;
4052 }
4053
4054 /* analog capture with dynamic dual-adc changes */
4055 static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4056                                        struct hda_codec *codec,
4057                                        unsigned int stream_tag,
4058                                        unsigned int format,
4059                                        struct snd_pcm_substream *substream)
4060 {
4061         struct alc_spec *spec = codec->spec;
4062         spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
4063         spec->cur_adc_stream_tag = stream_tag;
4064         spec->cur_adc_format = format;
4065         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
4066         return 0;
4067 }
4068
4069 static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4070                                        struct hda_codec *codec,
4071                                        struct snd_pcm_substream *substream)
4072 {
4073         struct alc_spec *spec = codec->spec;
4074         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
4075         spec->cur_adc = 0;
4076         return 0;
4077 }
4078
4079 static struct hda_pcm_stream dualmic_pcm_analog_capture = {
4080         .substreams = 1,
4081         .channels_min = 2,
4082         .channels_max = 2,
4083         .nid = 0, /* fill later */
4084         .ops = {
4085                 .prepare = dualmic_capture_pcm_prepare,
4086                 .cleanup = dualmic_capture_pcm_cleanup
4087         },
4088 };
4089
4090 /*
4091  */
4092 static struct hda_pcm_stream alc880_pcm_analog_playback = {
4093         .substreams = 1,
4094         .channels_min = 2,
4095         .channels_max = 8,
4096         /* NID is set in alc_build_pcms */
4097         .ops = {
4098                 .open = alc880_playback_pcm_open,
4099                 .prepare = alc880_playback_pcm_prepare,
4100                 .cleanup = alc880_playback_pcm_cleanup
4101         },
4102 };
4103
4104 static struct hda_pcm_stream alc880_pcm_analog_capture = {
4105         .substreams = 1,
4106         .channels_min = 2,
4107         .channels_max = 2,
4108         /* NID is set in alc_build_pcms */
4109 };
4110
4111 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
4112         .substreams = 1,
4113         .channels_min = 2,
4114         .channels_max = 2,
4115         /* NID is set in alc_build_pcms */
4116 };
4117
4118 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
4119         .substreams = 2, /* can be overridden */
4120         .channels_min = 2,
4121         .channels_max = 2,
4122         /* NID is set in alc_build_pcms */
4123         .ops = {
4124                 .prepare = alc880_alt_capture_pcm_prepare,
4125                 .cleanup = alc880_alt_capture_pcm_cleanup
4126         },
4127 };
4128
4129 static struct hda_pcm_stream alc880_pcm_digital_playback = {
4130         .substreams = 1,
4131         .channels_min = 2,
4132         .channels_max = 2,
4133         /* NID is set in alc_build_pcms */
4134         .ops = {
4135                 .open = alc880_dig_playback_pcm_open,
4136                 .close = alc880_dig_playback_pcm_close,
4137                 .prepare = alc880_dig_playback_pcm_prepare,
4138                 .cleanup = alc880_dig_playback_pcm_cleanup
4139         },
4140 };
4141
4142 static struct hda_pcm_stream alc880_pcm_digital_capture = {
4143         .substreams = 1,
4144         .channels_min = 2,
4145         .channels_max = 2,
4146         /* NID is set in alc_build_pcms */
4147 };
4148
4149 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
4150 static struct hda_pcm_stream alc_pcm_null_stream = {
4151         .substreams = 0,
4152         .channels_min = 0,
4153         .channels_max = 0,
4154 };
4155
4156 static int alc_build_pcms(struct hda_codec *codec)
4157 {
4158         struct alc_spec *spec = codec->spec;
4159         struct hda_pcm *info = spec->pcm_rec;
4160         int i;
4161
4162         codec->num_pcms = 1;
4163         codec->pcm_info = info;
4164
4165         if (spec->no_analog)
4166                 goto skip_analog;
4167
4168         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
4169                  "%s Analog", codec->chip_name);
4170         info->name = spec->stream_name_analog;
4171
4172         if (spec->stream_analog_playback) {
4173                 if (snd_BUG_ON(!spec->multiout.dac_nids))
4174                         return -EINVAL;
4175                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
4176                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4177         }
4178         if (spec->stream_analog_capture) {
4179                 if (snd_BUG_ON(!spec->adc_nids))
4180                         return -EINVAL;
4181                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
4182                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4183         }
4184
4185         if (spec->channel_mode) {
4186                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
4187                 for (i = 0; i < spec->num_channel_mode; i++) {
4188                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
4189                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
4190                         }
4191                 }
4192         }
4193
4194  skip_analog:
4195         /* SPDIF for stream index #1 */
4196         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4197                 snprintf(spec->stream_name_digital,
4198                          sizeof(spec->stream_name_digital),
4199                          "%s Digital", codec->chip_name);
4200                 codec->num_pcms = 2;
4201                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4202                 info = spec->pcm_rec + 1;
4203                 info->name = spec->stream_name_digital;
4204                 if (spec->dig_out_type)
4205                         info->pcm_type = spec->dig_out_type;
4206                 else
4207                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
4208                 if (spec->multiout.dig_out_nid &&
4209                     spec->stream_digital_playback) {
4210                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
4211                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4212                 }
4213                 if (spec->dig_in_nid &&
4214                     spec->stream_digital_capture) {
4215                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
4216                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4217                 }
4218                 /* FIXME: do we need this for all Realtek codec models? */
4219                 codec->spdif_status_reset = 1;
4220         }
4221
4222         if (spec->no_analog)
4223                 return 0;
4224
4225         /* If the use of more than one ADC is requested for the current
4226          * model, configure a second analog capture-only PCM.
4227          */
4228         /* Additional Analaog capture for index #2 */
4229         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
4230             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
4231                 codec->num_pcms = 3;
4232                 info = spec->pcm_rec + 2;
4233                 info->name = spec->stream_name_analog;
4234                 if (spec->alt_dac_nid) {
4235                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4236                                 *spec->stream_analog_alt_playback;
4237                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4238                                 spec->alt_dac_nid;
4239                 } else {
4240                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4241                                 alc_pcm_null_stream;
4242                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4243                 }
4244                 if (spec->num_adc_nids > 1) {
4245                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4246                                 *spec->stream_analog_alt_capture;
4247                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4248                                 spec->adc_nids[1];
4249                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4250                                 spec->num_adc_nids - 1;
4251                 } else {
4252                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4253                                 alc_pcm_null_stream;
4254                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4255                 }
4256         }
4257
4258         return 0;
4259 }
4260
4261 static inline void alc_shutup(struct hda_codec *codec)
4262 {
4263         snd_hda_shutup_pins(codec);
4264 }
4265
4266 static void alc_free_kctls(struct hda_codec *codec)
4267 {
4268         struct alc_spec *spec = codec->spec;
4269
4270         if (spec->kctls.list) {
4271                 struct snd_kcontrol_new *kctl = spec->kctls.list;
4272                 int i;
4273                 for (i = 0; i < spec->kctls.used; i++)
4274                         kfree(kctl[i].name);
4275         }
4276         snd_array_free(&spec->kctls);
4277 }
4278
4279 static void alc_free(struct hda_codec *codec)
4280 {
4281         struct alc_spec *spec = codec->spec;
4282
4283         if (!spec)
4284                 return;
4285
4286         alc_shutup(codec);
4287         alc_free_kctls(codec);
4288         kfree(spec);
4289         snd_hda_detach_beep_device(codec);
4290 }
4291
4292 #ifdef CONFIG_SND_HDA_POWER_SAVE
4293 static void alc_power_eapd(struct hda_codec *codec)
4294 {
4295         /* We currently only handle front, HP */
4296         switch (codec->vendor_id) {
4297         case 0x10ec0260:
4298                 set_eapd(codec, 0x0f, 0);
4299                 set_eapd(codec, 0x10, 0);
4300                 break;
4301         case 0x10ec0262:
4302         case 0x10ec0267:
4303         case 0x10ec0268:
4304         case 0x10ec0269:
4305         case 0x10ec0270:
4306         case 0x10ec0272:
4307         case 0x10ec0660:
4308         case 0x10ec0662:
4309         case 0x10ec0663:
4310         case 0x10ec0862:
4311         case 0x10ec0889:
4312                 set_eapd(codec, 0x14, 0);
4313                 set_eapd(codec, 0x15, 0);
4314                 break;
4315         }
4316 }
4317
4318 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
4319 {
4320         struct alc_spec *spec = codec->spec;
4321         alc_shutup(codec);
4322         if (spec && spec->power_hook)
4323                 spec->power_hook(codec);
4324         return 0;
4325 }
4326 #endif
4327
4328 #ifdef SND_HDA_NEEDS_RESUME
4329 static int alc_resume(struct hda_codec *codec)
4330 {
4331         codec->patch_ops.init(codec);
4332         snd_hda_codec_resume_amp(codec);
4333         snd_hda_codec_resume_cache(codec);
4334         hda_call_check_power_status(codec, 0x01);
4335         return 0;
4336 }
4337 #endif
4338
4339 /*
4340  */
4341 static struct hda_codec_ops alc_patch_ops = {
4342         .build_controls = alc_build_controls,
4343         .build_pcms = alc_build_pcms,
4344         .init = alc_init,
4345         .free = alc_free,
4346         .unsol_event = alc_unsol_event,
4347 #ifdef SND_HDA_NEEDS_RESUME
4348         .resume = alc_resume,
4349 #endif
4350 #ifdef CONFIG_SND_HDA_POWER_SAVE
4351         .suspend = alc_suspend,
4352         .check_power_status = alc_check_power_status,
4353 #endif
4354         .reboot_notify = alc_shutup,
4355 };
4356
4357 /* replace the codec chip_name with the given string */
4358 static int alc_codec_rename(struct hda_codec *codec, const char *name)
4359 {
4360         kfree(codec->chip_name);
4361         codec->chip_name = kstrdup(name, GFP_KERNEL);
4362         if (!codec->chip_name) {
4363                 alc_free(codec);
4364                 return -ENOMEM;
4365         }
4366         return 0;
4367 }
4368
4369 /*
4370  * Test configuration for debugging
4371  *
4372  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
4373  * enum controls.
4374  */
4375 #ifdef CONFIG_SND_DEBUG
4376 static hda_nid_t alc880_test_dac_nids[4] = {
4377         0x02, 0x03, 0x04, 0x05
4378 };
4379
4380 static struct hda_input_mux alc880_test_capture_source = {
4381         .num_items = 7,
4382         .items = {
4383                 { "In-1", 0x0 },
4384                 { "In-2", 0x1 },
4385                 { "In-3", 0x2 },
4386                 { "In-4", 0x3 },
4387                 { "CD", 0x4 },
4388                 { "Front", 0x5 },
4389                 { "Surround", 0x6 },
4390         },
4391 };
4392
4393 static struct hda_channel_mode alc880_test_modes[4] = {
4394         { 2, NULL },
4395         { 4, NULL },
4396         { 6, NULL },
4397         { 8, NULL },
4398 };
4399
4400 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
4401                                  struct snd_ctl_elem_info *uinfo)
4402 {
4403         static char *texts[] = {
4404                 "N/A", "Line Out", "HP Out",
4405                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
4406         };
4407         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4408         uinfo->count = 1;
4409         uinfo->value.enumerated.items = 8;
4410         if (uinfo->value.enumerated.item >= 8)
4411                 uinfo->value.enumerated.item = 7;
4412         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4413         return 0;
4414 }
4415
4416 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
4417                                 struct snd_ctl_elem_value *ucontrol)
4418 {
4419         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4420         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4421         unsigned int pin_ctl, item = 0;
4422
4423         pin_ctl = snd_hda_codec_read(codec, nid, 0,
4424                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4425         if (pin_ctl & AC_PINCTL_OUT_EN) {
4426                 if (pin_ctl & AC_PINCTL_HP_EN)
4427                         item = 2;
4428                 else
4429                         item = 1;
4430         } else if (pin_ctl & AC_PINCTL_IN_EN) {
4431                 switch (pin_ctl & AC_PINCTL_VREFEN) {
4432                 case AC_PINCTL_VREF_HIZ: item = 3; break;
4433                 case AC_PINCTL_VREF_50:  item = 4; break;
4434                 case AC_PINCTL_VREF_GRD: item = 5; break;
4435                 case AC_PINCTL_VREF_80:  item = 6; break;
4436                 case AC_PINCTL_VREF_100: item = 7; break;
4437                 }
4438         }
4439         ucontrol->value.enumerated.item[0] = item;
4440         return 0;
4441 }
4442
4443 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
4444                                 struct snd_ctl_elem_value *ucontrol)
4445 {
4446         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4447         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4448         static unsigned int ctls[] = {
4449                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
4450                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
4451                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
4452                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
4453                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
4454                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
4455         };
4456         unsigned int old_ctl, new_ctl;
4457
4458         old_ctl = snd_hda_codec_read(codec, nid, 0,
4459                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4460         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
4461         if (old_ctl != new_ctl) {
4462                 int val;
4463                 snd_hda_codec_write_cache(codec, nid, 0,
4464                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4465                                           new_ctl);
4466                 val = ucontrol->value.enumerated.item[0] >= 3 ?
4467                         HDA_AMP_MUTE : 0;
4468                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
4469                                          HDA_AMP_MUTE, val);
4470                 return 1;
4471         }
4472         return 0;
4473 }
4474
4475 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
4476                                  struct snd_ctl_elem_info *uinfo)
4477 {
4478         static char *texts[] = {
4479                 "Front", "Surround", "CLFE", "Side"
4480         };
4481         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4482         uinfo->count = 1;
4483         uinfo->value.enumerated.items = 4;
4484         if (uinfo->value.enumerated.item >= 4)
4485                 uinfo->value.enumerated.item = 3;
4486         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4487         return 0;
4488 }
4489
4490 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
4491                                 struct snd_ctl_elem_value *ucontrol)
4492 {
4493         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4494         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4495         unsigned int sel;
4496
4497         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
4498         ucontrol->value.enumerated.item[0] = sel & 3;
4499         return 0;
4500 }
4501
4502 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
4503                                 struct snd_ctl_elem_value *ucontrol)
4504 {
4505         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4506         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4507         unsigned int sel;
4508
4509         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
4510         if (ucontrol->value.enumerated.item[0] != sel) {
4511                 sel = ucontrol->value.enumerated.item[0] & 3;
4512                 snd_hda_codec_write_cache(codec, nid, 0,
4513                                           AC_VERB_SET_CONNECT_SEL, sel);
4514                 return 1;
4515         }
4516         return 0;
4517 }
4518
4519 #define PIN_CTL_TEST(xname,nid) {                       \
4520                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4521                         .name = xname,                 \
4522                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4523                         .info = alc_test_pin_ctl_info, \
4524                         .get = alc_test_pin_ctl_get,   \
4525                         .put = alc_test_pin_ctl_put,   \
4526                         .private_value = nid           \
4527                         }
4528
4529 #define PIN_SRC_TEST(xname,nid) {                       \
4530                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4531                         .name = xname,                 \
4532                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4533                         .info = alc_test_pin_src_info, \
4534                         .get = alc_test_pin_src_get,   \
4535                         .put = alc_test_pin_src_put,   \
4536                         .private_value = nid           \
4537                         }
4538
4539 static struct snd_kcontrol_new alc880_test_mixer[] = {
4540         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4541         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4542         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
4543         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4544         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4545         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4546         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
4547         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4548         PIN_CTL_TEST("Front Pin Mode", 0x14),
4549         PIN_CTL_TEST("Surround Pin Mode", 0x15),
4550         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
4551         PIN_CTL_TEST("Side Pin Mode", 0x17),
4552         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
4553         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
4554         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
4555         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
4556         PIN_SRC_TEST("In-1 Pin Source", 0x18),
4557         PIN_SRC_TEST("In-2 Pin Source", 0x19),
4558         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
4559         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
4560         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
4561         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
4562         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
4563         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
4564         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
4565         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
4566         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
4567         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
4568         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
4569         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
4570         {
4571                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4572                 .name = "Channel Mode",
4573                 .info = alc_ch_mode_info,
4574                 .get = alc_ch_mode_get,
4575                 .put = alc_ch_mode_put,
4576         },
4577         { } /* end */
4578 };
4579
4580 static struct hda_verb alc880_test_init_verbs[] = {
4581         /* Unmute inputs of 0x0c - 0x0f */
4582         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4583         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4584         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4585         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4586         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4587         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4588         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4589         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4590         /* Vol output for 0x0c-0x0f */
4591         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4592         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4593         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4594         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4595         /* Set output pins 0x14-0x17 */
4596         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4597         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4598         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4599         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4600         /* Unmute output pins 0x14-0x17 */
4601         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4602         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4603         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4604         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4605         /* Set input pins 0x18-0x1c */
4606         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4607         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4608         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4609         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4610         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4611         /* Mute input pins 0x18-0x1b */
4612         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4613         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4614         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4615         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4616         /* ADC set up */
4617         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4618         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4619         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4620         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4621         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4622         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4623         /* Analog input/passthru */
4624         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4625         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4626         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4627         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4628         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4629         { }
4630 };
4631 #endif
4632
4633 /*
4634  */
4635
4636 static const char * const alc880_models[ALC880_MODEL_LAST] = {
4637         [ALC880_3ST]            = "3stack",
4638         [ALC880_TCL_S700]       = "tcl",
4639         [ALC880_3ST_DIG]        = "3stack-digout",
4640         [ALC880_CLEVO]          = "clevo",
4641         [ALC880_5ST]            = "5stack",
4642         [ALC880_5ST_DIG]        = "5stack-digout",
4643         [ALC880_W810]           = "w810",
4644         [ALC880_Z71V]           = "z71v",
4645         [ALC880_6ST]            = "6stack",
4646         [ALC880_6ST_DIG]        = "6stack-digout",
4647         [ALC880_ASUS]           = "asus",
4648         [ALC880_ASUS_W1V]       = "asus-w1v",
4649         [ALC880_ASUS_DIG]       = "asus-dig",
4650         [ALC880_ASUS_DIG2]      = "asus-dig2",
4651         [ALC880_UNIWILL_DIG]    = "uniwill",
4652         [ALC880_UNIWILL_P53]    = "uniwill-p53",
4653         [ALC880_FUJITSU]        = "fujitsu",
4654         [ALC880_F1734]          = "F1734",
4655         [ALC880_LG]             = "lg",
4656         [ALC880_LG_LW]          = "lg-lw",
4657         [ALC880_MEDION_RIM]     = "medion",
4658 #ifdef CONFIG_SND_DEBUG
4659         [ALC880_TEST]           = "test",
4660 #endif
4661         [ALC880_AUTO]           = "auto",
4662 };
4663
4664 static struct snd_pci_quirk alc880_cfg_tbl[] = {
4665         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4666         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4667         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4668         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4669         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4670         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4671         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4672         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4673         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4674         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4675         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4676         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4677         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4678         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4679         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4680         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4681         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4682         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4683         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4684         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4685         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4686         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4687         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4688         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4689         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4690         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4691         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4692         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4693         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4694         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4695         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4696         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4697         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4698         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4699         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4700         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4701         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4702         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4703         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4704         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4705         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4706         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4707         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4708         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4709         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4710         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4711         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4712         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4713         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4714         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
4715         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4716         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4717         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4718         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_LG),
4719         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4720         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4721         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4722         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4723         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4724         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4725         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4726         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4727         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4728         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4729         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4730         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4731         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4732         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4733         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4734         /* default Intel */
4735         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4736         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4737         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4738         {}
4739 };
4740
4741 /*
4742  * ALC880 codec presets
4743  */
4744 static struct alc_config_preset alc880_presets[] = {
4745         [ALC880_3ST] = {
4746                 .mixers = { alc880_three_stack_mixer },
4747                 .init_verbs = { alc880_volume_init_verbs,
4748                                 alc880_pin_3stack_init_verbs },
4749                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4750                 .dac_nids = alc880_dac_nids,
4751                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4752                 .channel_mode = alc880_threestack_modes,
4753                 .need_dac_fix = 1,
4754                 .input_mux = &alc880_capture_source,
4755         },
4756         [ALC880_3ST_DIG] = {
4757                 .mixers = { alc880_three_stack_mixer },
4758                 .init_verbs = { alc880_volume_init_verbs,
4759                                 alc880_pin_3stack_init_verbs },
4760                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4761                 .dac_nids = alc880_dac_nids,
4762                 .dig_out_nid = ALC880_DIGOUT_NID,
4763                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4764                 .channel_mode = alc880_threestack_modes,
4765                 .need_dac_fix = 1,
4766                 .input_mux = &alc880_capture_source,
4767         },
4768         [ALC880_TCL_S700] = {
4769                 .mixers = { alc880_tcl_s700_mixer },
4770                 .init_verbs = { alc880_volume_init_verbs,
4771                                 alc880_pin_tcl_S700_init_verbs,
4772                                 alc880_gpio2_init_verbs },
4773                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4774                 .dac_nids = alc880_dac_nids,
4775                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4776                 .num_adc_nids = 1, /* single ADC */
4777                 .hp_nid = 0x03,
4778                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4779                 .channel_mode = alc880_2_jack_modes,
4780                 .input_mux = &alc880_capture_source,
4781         },
4782         [ALC880_5ST] = {
4783                 .mixers = { alc880_three_stack_mixer,
4784                             alc880_five_stack_mixer},
4785                 .init_verbs = { alc880_volume_init_verbs,
4786                                 alc880_pin_5stack_init_verbs },
4787                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4788                 .dac_nids = alc880_dac_nids,
4789                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4790                 .channel_mode = alc880_fivestack_modes,
4791                 .input_mux = &alc880_capture_source,
4792         },
4793         [ALC880_5ST_DIG] = {
4794                 .mixers = { alc880_three_stack_mixer,
4795                             alc880_five_stack_mixer },
4796                 .init_verbs = { alc880_volume_init_verbs,
4797                                 alc880_pin_5stack_init_verbs },
4798                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4799                 .dac_nids = alc880_dac_nids,
4800                 .dig_out_nid = ALC880_DIGOUT_NID,
4801                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4802                 .channel_mode = alc880_fivestack_modes,
4803                 .input_mux = &alc880_capture_source,
4804         },
4805         [ALC880_6ST] = {
4806                 .mixers = { alc880_six_stack_mixer },
4807                 .init_verbs = { alc880_volume_init_verbs,
4808                                 alc880_pin_6stack_init_verbs },
4809                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4810                 .dac_nids = alc880_6st_dac_nids,
4811                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4812                 .channel_mode = alc880_sixstack_modes,
4813                 .input_mux = &alc880_6stack_capture_source,
4814         },
4815         [ALC880_6ST_DIG] = {
4816                 .mixers = { alc880_six_stack_mixer },
4817                 .init_verbs = { alc880_volume_init_verbs,
4818                                 alc880_pin_6stack_init_verbs },
4819                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4820                 .dac_nids = alc880_6st_dac_nids,
4821                 .dig_out_nid = ALC880_DIGOUT_NID,
4822                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4823                 .channel_mode = alc880_sixstack_modes,
4824                 .input_mux = &alc880_6stack_capture_source,
4825         },
4826         [ALC880_W810] = {
4827                 .mixers = { alc880_w810_base_mixer },
4828                 .init_verbs = { alc880_volume_init_verbs,
4829                                 alc880_pin_w810_init_verbs,
4830                                 alc880_gpio2_init_verbs },
4831                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4832                 .dac_nids = alc880_w810_dac_nids,
4833                 .dig_out_nid = ALC880_DIGOUT_NID,
4834                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4835                 .channel_mode = alc880_w810_modes,
4836                 .input_mux = &alc880_capture_source,
4837         },
4838         [ALC880_Z71V] = {
4839                 .mixers = { alc880_z71v_mixer },
4840                 .init_verbs = { alc880_volume_init_verbs,
4841                                 alc880_pin_z71v_init_verbs },
4842                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4843                 .dac_nids = alc880_z71v_dac_nids,
4844                 .dig_out_nid = ALC880_DIGOUT_NID,
4845                 .hp_nid = 0x03,
4846                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4847                 .channel_mode = alc880_2_jack_modes,
4848                 .input_mux = &alc880_capture_source,
4849         },
4850         [ALC880_F1734] = {
4851                 .mixers = { alc880_f1734_mixer },
4852                 .init_verbs = { alc880_volume_init_verbs,
4853                                 alc880_pin_f1734_init_verbs },
4854                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4855                 .dac_nids = alc880_f1734_dac_nids,
4856                 .hp_nid = 0x02,
4857                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4858                 .channel_mode = alc880_2_jack_modes,
4859                 .input_mux = &alc880_f1734_capture_source,
4860                 .unsol_event = alc880_uniwill_p53_unsol_event,
4861                 .setup = alc880_uniwill_p53_setup,
4862                 .init_hook = alc_automute_amp,
4863         },
4864         [ALC880_ASUS] = {
4865                 .mixers = { alc880_asus_mixer },
4866                 .init_verbs = { alc880_volume_init_verbs,
4867                                 alc880_pin_asus_init_verbs,
4868                                 alc880_gpio1_init_verbs },
4869                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4870                 .dac_nids = alc880_asus_dac_nids,
4871                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4872                 .channel_mode = alc880_asus_modes,
4873                 .need_dac_fix = 1,
4874                 .input_mux = &alc880_capture_source,
4875         },
4876         [ALC880_ASUS_DIG] = {
4877                 .mixers = { alc880_asus_mixer },
4878                 .init_verbs = { alc880_volume_init_verbs,
4879                                 alc880_pin_asus_init_verbs,
4880                                 alc880_gpio1_init_verbs },
4881                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4882                 .dac_nids = alc880_asus_dac_nids,
4883                 .dig_out_nid = ALC880_DIGOUT_NID,
4884                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4885                 .channel_mode = alc880_asus_modes,
4886                 .need_dac_fix = 1,
4887                 .input_mux = &alc880_capture_source,
4888         },
4889         [ALC880_ASUS_DIG2] = {
4890                 .mixers = { alc880_asus_mixer },
4891                 .init_verbs = { alc880_volume_init_verbs,
4892                                 alc880_pin_asus_init_verbs,
4893                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4894                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4895                 .dac_nids = alc880_asus_dac_nids,
4896                 .dig_out_nid = ALC880_DIGOUT_NID,
4897                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4898                 .channel_mode = alc880_asus_modes,
4899                 .need_dac_fix = 1,
4900                 .input_mux = &alc880_capture_source,
4901         },
4902         [ALC880_ASUS_W1V] = {
4903                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4904                 .init_verbs = { alc880_volume_init_verbs,
4905                                 alc880_pin_asus_init_verbs,
4906                                 alc880_gpio1_init_verbs },
4907                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4908                 .dac_nids = alc880_asus_dac_nids,
4909                 .dig_out_nid = ALC880_DIGOUT_NID,
4910                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4911                 .channel_mode = alc880_asus_modes,
4912                 .need_dac_fix = 1,
4913                 .input_mux = &alc880_capture_source,
4914         },
4915         [ALC880_UNIWILL_DIG] = {
4916                 .mixers = { alc880_asus_mixer },
4917                 .init_verbs = { alc880_volume_init_verbs,
4918                                 alc880_pin_asus_init_verbs },
4919                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4920                 .dac_nids = alc880_asus_dac_nids,
4921                 .dig_out_nid = ALC880_DIGOUT_NID,
4922                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4923                 .channel_mode = alc880_asus_modes,
4924                 .need_dac_fix = 1,
4925                 .input_mux = &alc880_capture_source,
4926         },
4927         [ALC880_UNIWILL] = {
4928                 .mixers = { alc880_uniwill_mixer },
4929                 .init_verbs = { alc880_volume_init_verbs,
4930                                 alc880_uniwill_init_verbs },
4931                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4932                 .dac_nids = alc880_asus_dac_nids,
4933                 .dig_out_nid = ALC880_DIGOUT_NID,
4934                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4935                 .channel_mode = alc880_threestack_modes,
4936                 .need_dac_fix = 1,
4937                 .input_mux = &alc880_capture_source,
4938                 .unsol_event = alc880_uniwill_unsol_event,
4939                 .setup = alc880_uniwill_setup,
4940                 .init_hook = alc880_uniwill_init_hook,
4941         },
4942         [ALC880_UNIWILL_P53] = {
4943                 .mixers = { alc880_uniwill_p53_mixer },
4944                 .init_verbs = { alc880_volume_init_verbs,
4945                                 alc880_uniwill_p53_init_verbs },
4946                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4947                 .dac_nids = alc880_asus_dac_nids,
4948                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4949                 .channel_mode = alc880_threestack_modes,
4950                 .input_mux = &alc880_capture_source,
4951                 .unsol_event = alc880_uniwill_p53_unsol_event,
4952                 .setup = alc880_uniwill_p53_setup,
4953                 .init_hook = alc_automute_amp,
4954         },
4955         [ALC880_FUJITSU] = {
4956                 .mixers = { alc880_fujitsu_mixer },
4957                 .init_verbs = { alc880_volume_init_verbs,
4958                                 alc880_uniwill_p53_init_verbs,
4959                                 alc880_beep_init_verbs },
4960                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4961                 .dac_nids = alc880_dac_nids,
4962                 .dig_out_nid = ALC880_DIGOUT_NID,
4963                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4964                 .channel_mode = alc880_2_jack_modes,
4965                 .input_mux = &alc880_capture_source,
4966                 .unsol_event = alc880_uniwill_p53_unsol_event,
4967                 .setup = alc880_uniwill_p53_setup,
4968                 .init_hook = alc_automute_amp,
4969         },
4970         [ALC880_CLEVO] = {
4971                 .mixers = { alc880_three_stack_mixer },
4972                 .init_verbs = { alc880_volume_init_verbs,
4973                                 alc880_pin_clevo_init_verbs },
4974                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4975                 .dac_nids = alc880_dac_nids,
4976                 .hp_nid = 0x03,
4977                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4978                 .channel_mode = alc880_threestack_modes,
4979                 .need_dac_fix = 1,
4980                 .input_mux = &alc880_capture_source,
4981         },
4982         [ALC880_LG] = {
4983                 .mixers = { alc880_lg_mixer },
4984                 .init_verbs = { alc880_volume_init_verbs,
4985                                 alc880_lg_init_verbs },
4986                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4987                 .dac_nids = alc880_lg_dac_nids,
4988                 .dig_out_nid = ALC880_DIGOUT_NID,
4989                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4990                 .channel_mode = alc880_lg_ch_modes,
4991                 .need_dac_fix = 1,
4992                 .input_mux = &alc880_lg_capture_source,
4993                 .unsol_event = alc_automute_amp_unsol_event,
4994                 .setup = alc880_lg_setup,
4995                 .init_hook = alc_automute_amp,
4996 #ifdef CONFIG_SND_HDA_POWER_SAVE
4997                 .loopbacks = alc880_lg_loopbacks,
4998 #endif
4999         },
5000         [ALC880_LG_LW] = {
5001                 .mixers = { alc880_lg_lw_mixer },
5002                 .init_verbs = { alc880_volume_init_verbs,
5003                                 alc880_lg_lw_init_verbs },
5004                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5005                 .dac_nids = alc880_dac_nids,
5006                 .dig_out_nid = ALC880_DIGOUT_NID,
5007                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
5008                 .channel_mode = alc880_lg_lw_modes,
5009                 .input_mux = &alc880_lg_lw_capture_source,
5010                 .unsol_event = alc_automute_amp_unsol_event,
5011                 .setup = alc880_lg_lw_setup,
5012                 .init_hook = alc_automute_amp,
5013         },
5014         [ALC880_MEDION_RIM] = {
5015                 .mixers = { alc880_medion_rim_mixer },
5016                 .init_verbs = { alc880_volume_init_verbs,
5017                                 alc880_medion_rim_init_verbs,
5018                                 alc_gpio2_init_verbs },
5019                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5020                 .dac_nids = alc880_dac_nids,
5021                 .dig_out_nid = ALC880_DIGOUT_NID,
5022                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
5023                 .channel_mode = alc880_2_jack_modes,
5024                 .input_mux = &alc880_medion_rim_capture_source,
5025                 .unsol_event = alc880_medion_rim_unsol_event,
5026                 .setup = alc880_medion_rim_setup,
5027                 .init_hook = alc880_medion_rim_automute,
5028         },
5029 #ifdef CONFIG_SND_DEBUG
5030         [ALC880_TEST] = {
5031                 .mixers = { alc880_test_mixer },
5032                 .init_verbs = { alc880_test_init_verbs },
5033                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
5034                 .dac_nids = alc880_test_dac_nids,
5035                 .dig_out_nid = ALC880_DIGOUT_NID,
5036                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
5037                 .channel_mode = alc880_test_modes,
5038                 .input_mux = &alc880_test_capture_source,
5039         },
5040 #endif
5041 };
5042
5043 /*
5044  * Automatic parse of I/O pins from the BIOS configuration
5045  */
5046
5047 enum {
5048         ALC_CTL_WIDGET_VOL,
5049         ALC_CTL_WIDGET_MUTE,
5050         ALC_CTL_BIND_MUTE,
5051 };
5052 static struct snd_kcontrol_new alc880_control_templates[] = {
5053         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
5054         HDA_CODEC_MUTE(NULL, 0, 0, 0),
5055         HDA_BIND_MUTE(NULL, 0, 0, 0),
5056 };
5057
5058 /* add dynamic controls */
5059 static int add_control(struct alc_spec *spec, int type, const char *name,
5060                        int cidx, unsigned long val)
5061 {
5062         struct snd_kcontrol_new *knew;
5063
5064         snd_array_init(&spec->kctls, sizeof(*knew), 32);
5065         knew = snd_array_new(&spec->kctls);
5066         if (!knew)
5067                 return -ENOMEM;
5068         *knew = alc880_control_templates[type];
5069         knew->name = kstrdup(name, GFP_KERNEL);
5070         if (!knew->name)
5071                 return -ENOMEM;
5072         knew->index = cidx;
5073         if (get_amp_nid_(val))
5074                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
5075         knew->private_value = val;
5076         return 0;
5077 }
5078
5079 static int add_control_with_pfx(struct alc_spec *spec, int type,
5080                                 const char *pfx, const char *dir,
5081                                 const char *sfx, int cidx, unsigned long val)
5082 {
5083         char name[32];
5084         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
5085         return add_control(spec, type, name, cidx, val);
5086 }
5087
5088 #define add_pb_vol_ctrl(spec, type, pfx, val)                   \
5089         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
5090 #define add_pb_sw_ctrl(spec, type, pfx, val)                    \
5091         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
5092 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)                   \
5093         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
5094 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)                    \
5095         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
5096
5097 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
5098 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
5099 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
5100 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
5101 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
5102 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
5103 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
5104 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
5105 #define ALC880_PIN_CD_NID               0x1c
5106
5107 /* fill in the dac_nids table from the parsed pin configuration */
5108 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
5109                                      const struct auto_pin_cfg *cfg)
5110 {
5111         hda_nid_t nid;
5112         int assigned[4];
5113         int i, j;
5114
5115         memset(assigned, 0, sizeof(assigned));
5116         spec->multiout.dac_nids = spec->private_dac_nids;
5117
5118         /* check the pins hardwired to audio widget */
5119         for (i = 0; i < cfg->line_outs; i++) {
5120                 nid = cfg->line_out_pins[i];
5121                 if (alc880_is_fixed_pin(nid)) {
5122                         int idx = alc880_fixed_pin_idx(nid);
5123                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
5124                         assigned[idx] = 1;
5125                 }
5126         }
5127         /* left pins can be connect to any audio widget */
5128         for (i = 0; i < cfg->line_outs; i++) {
5129                 nid = cfg->line_out_pins[i];
5130                 if (alc880_is_fixed_pin(nid))
5131                         continue;
5132                 /* search for an empty channel */
5133                 for (j = 0; j < cfg->line_outs; j++) {
5134                         if (!assigned[j]) {
5135                                 spec->multiout.dac_nids[i] =
5136                                         alc880_idx_to_dac(j);
5137                                 assigned[j] = 1;
5138                                 break;
5139                         }
5140                 }
5141         }
5142         spec->multiout.num_dacs = cfg->line_outs;
5143         return 0;
5144 }
5145
5146 static const char *alc_get_line_out_pfx(const struct auto_pin_cfg *cfg,
5147                                         bool can_be_master)
5148 {
5149         if (!cfg->hp_outs && !cfg->speaker_outs && can_be_master)
5150                 return "Master";
5151
5152         switch (cfg->line_out_type) {
5153         case AUTO_PIN_SPEAKER_OUT:
5154                 return "Speaker";
5155         case AUTO_PIN_HP_OUT:
5156                 return "Headphone";
5157         default:
5158                 if (cfg->line_outs == 1)
5159                         return "PCM";
5160                 break;
5161         }
5162         return NULL;
5163 }
5164
5165 /* add playback controls from the parsed DAC table */
5166 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
5167                                              const struct auto_pin_cfg *cfg)
5168 {
5169         static const char * const chname[4] = {
5170                 "Front", "Surround", NULL /*CLFE*/, "Side"
5171         };
5172         const char *pfx = alc_get_line_out_pfx(cfg, false);
5173         hda_nid_t nid;
5174         int i, err;
5175
5176         for (i = 0; i < cfg->line_outs; i++) {
5177                 if (!spec->multiout.dac_nids[i])
5178                         continue;
5179                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
5180                 if (!pfx && i == 2) {
5181                         /* Center/LFE */
5182                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5183                                               "Center",
5184                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
5185                                                               HDA_OUTPUT));
5186                         if (err < 0)
5187                                 return err;
5188                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5189                                               "LFE",
5190                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
5191                                                               HDA_OUTPUT));
5192                         if (err < 0)
5193                                 return err;
5194                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5195                                              "Center",
5196                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
5197                                                               HDA_INPUT));
5198                         if (err < 0)
5199                                 return err;
5200                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5201                                              "LFE",
5202                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
5203                                                               HDA_INPUT));
5204                         if (err < 0)
5205                                 return err;
5206                 } else {
5207                         const char *name = pfx;
5208                         if (!name)
5209                                 name = chname[i];
5210                         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5211                                                 name, i,
5212                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
5213                                                               HDA_OUTPUT));
5214                         if (err < 0)
5215                                 return err;
5216                         err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5217                                                name, i,
5218                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
5219                                                               HDA_INPUT));
5220                         if (err < 0)
5221                                 return err;
5222                 }
5223         }
5224         return 0;
5225 }
5226
5227 /* add playback controls for speaker and HP outputs */
5228 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
5229                                         const char *pfx)
5230 {
5231         hda_nid_t nid;
5232         int err;
5233
5234         if (!pin)
5235                 return 0;
5236
5237         if (alc880_is_fixed_pin(pin)) {
5238                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
5239                 /* specify the DAC as the extra output */
5240                 if (!spec->multiout.hp_nid)
5241                         spec->multiout.hp_nid = nid;
5242                 else
5243                         spec->multiout.extra_out_nid[0] = nid;
5244                 /* control HP volume/switch on the output mixer amp */
5245                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
5246                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5247                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
5248                 if (err < 0)
5249                         return err;
5250                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5251                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
5252                 if (err < 0)
5253                         return err;
5254         } else if (alc880_is_multi_pin(pin)) {
5255                 /* set manual connection */
5256                 /* we have only a switch on HP-out PIN */
5257                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
5258                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
5259                 if (err < 0)
5260                         return err;
5261         }
5262         return 0;
5263 }
5264
5265 /* create input playback/capture controls for the given pin */
5266 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
5267                             const char *ctlname, int ctlidx,
5268                             int idx, hda_nid_t mix_nid)
5269 {
5270         int err;
5271
5272         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
5273                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5274         if (err < 0)
5275                 return err;
5276         err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
5277                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5278         if (err < 0)
5279                 return err;
5280         return 0;
5281 }
5282
5283 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
5284 {
5285         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
5286         return (pincap & AC_PINCAP_IN) != 0;
5287 }
5288
5289 /* create playback/capture controls for input pins */
5290 static int alc_auto_create_input_ctls(struct hda_codec *codec,
5291                                       const struct auto_pin_cfg *cfg,
5292                                       hda_nid_t mixer,
5293                                       hda_nid_t cap1, hda_nid_t cap2)
5294 {
5295         struct alc_spec *spec = codec->spec;
5296         struct hda_input_mux *imux = &spec->private_imux[0];
5297         int i, err, idx, type_idx = 0;
5298         const char *prev_label = NULL;
5299
5300         for (i = 0; i < cfg->num_inputs; i++) {
5301                 hda_nid_t pin;
5302                 const char *label;
5303
5304                 pin = cfg->inputs[i].pin;
5305                 if (!alc_is_input_pin(codec, pin))
5306                         continue;
5307
5308                 label = hda_get_autocfg_input_label(codec, cfg, i);
5309                 if (prev_label && !strcmp(label, prev_label))
5310                         type_idx++;
5311                 else
5312                         type_idx = 0;
5313                 prev_label = label;
5314
5315                 if (mixer) {
5316                         idx = get_connection_index(codec, mixer, pin);
5317                         if (idx >= 0) {
5318                                 err = new_analog_input(spec, pin,
5319                                                        label, type_idx,
5320                                                        idx, mixer);
5321                                 if (err < 0)
5322                                         return err;
5323                         }
5324                 }
5325
5326                 if (!cap1)
5327                         continue;
5328                 idx = get_connection_index(codec, cap1, pin);
5329                 if (idx < 0 && cap2)
5330                         idx = get_connection_index(codec, cap2, pin);
5331                 if (idx >= 0)
5332                         snd_hda_add_imux_item(imux, label, idx, NULL);
5333         }
5334         return 0;
5335 }
5336
5337 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
5338                                                 const struct auto_pin_cfg *cfg)
5339 {
5340         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
5341 }
5342
5343 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
5344                                unsigned int pin_type)
5345 {
5346         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5347                             pin_type);
5348         /* unmute pin */
5349         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
5350                             AMP_OUT_UNMUTE);
5351 }
5352
5353 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
5354                                               hda_nid_t nid, int pin_type,
5355                                               int dac_idx)
5356 {
5357         alc_set_pin_output(codec, nid, pin_type);
5358         /* need the manual connection? */
5359         if (alc880_is_multi_pin(nid)) {
5360                 struct alc_spec *spec = codec->spec;
5361                 int idx = alc880_multi_pin_idx(nid);
5362                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
5363                                     AC_VERB_SET_CONNECT_SEL,
5364                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
5365         }
5366 }
5367
5368 static int get_pin_type(int line_out_type)
5369 {
5370         if (line_out_type == AUTO_PIN_HP_OUT)
5371                 return PIN_HP;
5372         else
5373                 return PIN_OUT;
5374 }
5375
5376 static void alc880_auto_init_multi_out(struct hda_codec *codec)
5377 {
5378         struct alc_spec *spec = codec->spec;
5379         int i;
5380
5381         for (i = 0; i < spec->autocfg.line_outs; i++) {
5382                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
5383                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5384                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
5385         }
5386 }
5387
5388 static void alc880_auto_init_extra_out(struct hda_codec *codec)
5389 {
5390         struct alc_spec *spec = codec->spec;
5391         hda_nid_t pin;
5392
5393         pin = spec->autocfg.speaker_pins[0];
5394         if (pin) /* connect to front */
5395                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
5396         pin = spec->autocfg.hp_pins[0];
5397         if (pin) /* connect to front */
5398                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
5399 }
5400
5401 static void alc880_auto_init_analog_input(struct hda_codec *codec)
5402 {
5403         struct alc_spec *spec = codec->spec;
5404         struct auto_pin_cfg *cfg = &spec->autocfg;
5405         int i;
5406
5407         for (i = 0; i < cfg->num_inputs; i++) {
5408                 hda_nid_t nid = cfg->inputs[i].pin;
5409                 if (alc_is_input_pin(codec, nid)) {
5410                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
5411                         if (nid != ALC880_PIN_CD_NID &&
5412                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5413                                 snd_hda_codec_write(codec, nid, 0,
5414                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5415                                                     AMP_OUT_MUTE);
5416                 }
5417         }
5418 }
5419
5420 static void alc880_auto_init_input_src(struct hda_codec *codec)
5421 {
5422         struct alc_spec *spec = codec->spec;
5423         int c;
5424
5425         for (c = 0; c < spec->num_adc_nids; c++) {
5426                 unsigned int mux_idx;
5427                 const struct hda_input_mux *imux;
5428                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
5429                 imux = &spec->input_mux[mux_idx];
5430                 if (!imux->num_items && mux_idx > 0)
5431                         imux = &spec->input_mux[0];
5432                 if (imux)
5433                         snd_hda_codec_write(codec, spec->adc_nids[c], 0,
5434                                             AC_VERB_SET_CONNECT_SEL,
5435                                             imux->items[0].index);
5436         }
5437 }
5438
5439 /* parse the BIOS configuration and set up the alc_spec */
5440 /* return 1 if successful, 0 if the proper config is not found,
5441  * or a negative error code
5442  */
5443 static int alc880_parse_auto_config(struct hda_codec *codec)
5444 {
5445         struct alc_spec *spec = codec->spec;
5446         int err;
5447         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
5448
5449         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5450                                            alc880_ignore);
5451         if (err < 0)
5452                 return err;
5453         if (!spec->autocfg.line_outs)
5454                 return 0; /* can't find valid BIOS pin config */
5455
5456         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
5457         if (err < 0)
5458                 return err;
5459         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
5460         if (err < 0)
5461                 return err;
5462         err = alc880_auto_create_extra_out(spec,
5463                                            spec->autocfg.speaker_pins[0],
5464                                            "Speaker");
5465         if (err < 0)
5466                 return err;
5467         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
5468                                            "Headphone");
5469         if (err < 0)
5470                 return err;
5471         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
5472         if (err < 0)
5473                 return err;
5474
5475         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5476
5477         alc_auto_parse_digital(codec);
5478
5479         if (spec->kctls.list)
5480                 add_mixer(spec, spec->kctls.list);
5481
5482         add_verb(spec, alc880_volume_init_verbs);
5483
5484         spec->num_mux_defs = 1;
5485         spec->input_mux = &spec->private_imux[0];
5486
5487         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
5488
5489         return 1;
5490 }
5491
5492 /* additional initialization for auto-configuration model */
5493 static void alc880_auto_init(struct hda_codec *codec)
5494 {
5495         struct alc_spec *spec = codec->spec;
5496         alc880_auto_init_multi_out(codec);
5497         alc880_auto_init_extra_out(codec);
5498         alc880_auto_init_analog_input(codec);
5499         alc880_auto_init_input_src(codec);
5500         alc_auto_init_digital(codec);
5501         if (spec->unsol_event)
5502                 alc_inithook(codec);
5503 }
5504
5505 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
5506  * one of two digital mic pins, e.g. on ALC272
5507  */
5508 static void fixup_automic_adc(struct hda_codec *codec)
5509 {
5510         struct alc_spec *spec = codec->spec;
5511         int i;
5512
5513         for (i = 0; i < spec->num_adc_nids; i++) {
5514                 hda_nid_t cap = spec->capsrc_nids ?
5515                         spec->capsrc_nids[i] : spec->adc_nids[i];
5516                 int iidx, eidx;
5517
5518                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
5519                 if (iidx < 0)
5520                         continue;
5521                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
5522                 if (eidx < 0)
5523                         continue;
5524                 spec->int_mic.mux_idx = iidx;
5525                 spec->ext_mic.mux_idx = eidx;
5526                 if (spec->capsrc_nids)
5527                         spec->capsrc_nids += i;
5528                 spec->adc_nids += i;
5529                 spec->num_adc_nids = 1;
5530                 return;
5531         }
5532         snd_printd(KERN_INFO "hda_codec: %s: "
5533                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
5534                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
5535         spec->auto_mic = 0; /* disable auto-mic to be sure */
5536 }
5537
5538 /* select or unmute the given capsrc route */
5539 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
5540                                     int idx)
5541 {
5542         if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
5543                 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
5544                                          HDA_AMP_MUTE, 0);
5545         } else {
5546                 snd_hda_codec_write_cache(codec, cap, 0,
5547                                           AC_VERB_SET_CONNECT_SEL, idx);
5548         }
5549 }
5550
5551 /* set the default connection to that pin */
5552 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
5553 {
5554         struct alc_spec *spec = codec->spec;
5555         int i;
5556
5557         for (i = 0; i < spec->num_adc_nids; i++) {
5558                 hda_nid_t cap = spec->capsrc_nids ?
5559                         spec->capsrc_nids[i] : spec->adc_nids[i];
5560                 int idx;
5561
5562                 idx = get_connection_index(codec, cap, pin);
5563                 if (idx < 0)
5564                         continue;
5565                 select_or_unmute_capsrc(codec, cap, idx);
5566                 return i; /* return the found index */
5567         }
5568         return -1; /* not found */
5569 }
5570
5571 /* choose the ADC/MUX containing the input pin and initialize the setup */
5572 static void fixup_single_adc(struct hda_codec *codec)
5573 {
5574         struct alc_spec *spec = codec->spec;
5575         struct auto_pin_cfg *cfg = &spec->autocfg;
5576         int i;
5577
5578         /* search for the input pin; there must be only one */
5579         if (cfg->num_inputs != 1)
5580                 return;
5581         i = init_capsrc_for_pin(codec, cfg->inputs[0].pin);
5582         if (i >= 0) {
5583                 /* use only this ADC */
5584                 if (spec->capsrc_nids)
5585                         spec->capsrc_nids += i;
5586                 spec->adc_nids += i;
5587                 spec->num_adc_nids = 1;
5588         }
5589 }
5590
5591 /* initialize dual adcs */
5592 static void fixup_dual_adc_switch(struct hda_codec *codec)
5593 {
5594         struct alc_spec *spec = codec->spec;
5595         init_capsrc_for_pin(codec, spec->ext_mic.pin);
5596         init_capsrc_for_pin(codec, spec->int_mic.pin);
5597 }
5598
5599 static void set_capture_mixer(struct hda_codec *codec)
5600 {
5601         struct alc_spec *spec = codec->spec;
5602         static struct snd_kcontrol_new *caps[2][3] = {
5603                 { alc_capture_mixer_nosrc1,
5604                   alc_capture_mixer_nosrc2,
5605                   alc_capture_mixer_nosrc3 },
5606                 { alc_capture_mixer1,
5607                   alc_capture_mixer2,
5608                   alc_capture_mixer3 },
5609         };
5610         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
5611                 int mux = 0;
5612                 int num_adcs = spec->num_adc_nids;
5613                 if (spec->dual_adc_switch)
5614                         fixup_dual_adc_switch(codec);
5615                 else if (spec->auto_mic)
5616                         fixup_automic_adc(codec);
5617                 else if (spec->input_mux) {
5618                         if (spec->input_mux->num_items > 1)
5619                                 mux = 1;
5620                         else if (spec->input_mux->num_items == 1)
5621                                 fixup_single_adc(codec);
5622                 }
5623                 if (spec->dual_adc_switch)
5624                         num_adcs = 1;
5625                 spec->cap_mixer = caps[mux][num_adcs - 1];
5626         }
5627 }
5628
5629 /* fill adc_nids (and capsrc_nids) containing all active input pins */
5630 static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
5631                                  int num_nids)
5632 {
5633         struct alc_spec *spec = codec->spec;
5634         struct auto_pin_cfg *cfg = &spec->autocfg;
5635         int n;
5636         hda_nid_t fallback_adc = 0, fallback_cap = 0;
5637
5638         for (n = 0; n < num_nids; n++) {
5639                 hda_nid_t adc, cap;
5640                 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5641                 int nconns, i, j;
5642
5643                 adc = nids[n];
5644                 if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5645                         continue;
5646                 cap = adc;
5647                 nconns = snd_hda_get_connections(codec, cap, conn,
5648                                                  ARRAY_SIZE(conn));
5649                 if (nconns == 1) {
5650                         cap = conn[0];
5651                         nconns = snd_hda_get_connections(codec, cap, conn,
5652                                                          ARRAY_SIZE(conn));
5653                 }
5654                 if (nconns <= 0)
5655                         continue;
5656                 if (!fallback_adc) {
5657                         fallback_adc = adc;
5658                         fallback_cap = cap;
5659                 }
5660                 for (i = 0; i < cfg->num_inputs; i++) {
5661                         hda_nid_t nid = cfg->inputs[i].pin;
5662                         for (j = 0; j < nconns; j++) {
5663                                 if (conn[j] == nid)
5664                                         break;
5665                         }
5666                         if (j >= nconns)
5667                                 break;
5668                 }
5669                 if (i >= cfg->num_inputs) {
5670                         int num_adcs = spec->num_adc_nids;
5671                         spec->private_adc_nids[num_adcs] = adc;
5672                         spec->private_capsrc_nids[num_adcs] = cap;
5673                         spec->num_adc_nids++;
5674                         spec->adc_nids = spec->private_adc_nids;
5675                         if (adc != cap)
5676                                 spec->capsrc_nids = spec->private_capsrc_nids;
5677                 }
5678         }
5679         if (!spec->num_adc_nids) {
5680                 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5681                        " using fallback 0x%x\n",
5682                        codec->chip_name, fallback_adc);
5683                 spec->private_adc_nids[0] = fallback_adc;
5684                 spec->adc_nids = spec->private_adc_nids;
5685                 if (fallback_adc != fallback_cap) {
5686                         spec->private_capsrc_nids[0] = fallback_cap;
5687                         spec->capsrc_nids = spec->private_adc_nids;
5688                 }
5689         }
5690 }
5691
5692 #ifdef CONFIG_SND_HDA_INPUT_BEEP
5693 #define set_beep_amp(spec, nid, idx, dir) \
5694         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5695
5696 static struct snd_pci_quirk beep_white_list[] = {
5697         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
5698         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
5699         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
5700         {}
5701 };
5702
5703 static inline int has_cdefine_beep(struct hda_codec *codec)
5704 {
5705         struct alc_spec *spec = codec->spec;
5706         const struct snd_pci_quirk *q;
5707         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
5708         if (q)
5709                 return q->value;
5710         return spec->cdefine.enable_pcbeep;
5711 }
5712 #else
5713 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
5714 #define has_cdefine_beep(codec)         0
5715 #endif
5716
5717 /*
5718  * OK, here we have finally the patch for ALC880
5719  */
5720
5721 static int patch_alc880(struct hda_codec *codec)
5722 {
5723         struct alc_spec *spec;
5724         int board_config;
5725         int err;
5726
5727         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5728         if (spec == NULL)
5729                 return -ENOMEM;
5730
5731         codec->spec = spec;
5732
5733         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5734                                                   alc880_models,
5735                                                   alc880_cfg_tbl);
5736         if (board_config < 0) {
5737                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5738                        codec->chip_name);
5739                 board_config = ALC880_AUTO;
5740         }
5741
5742         if (board_config == ALC880_AUTO) {
5743                 /* automatic parse from the BIOS config */
5744                 err = alc880_parse_auto_config(codec);
5745                 if (err < 0) {
5746                         alc_free(codec);
5747                         return err;
5748                 } else if (!err) {
5749                         printk(KERN_INFO
5750                                "hda_codec: Cannot set up configuration "
5751                                "from BIOS.  Using 3-stack mode...\n");
5752                         board_config = ALC880_3ST;
5753                 }
5754         }
5755
5756         err = snd_hda_attach_beep_device(codec, 0x1);
5757         if (err < 0) {
5758                 alc_free(codec);
5759                 return err;
5760         }
5761
5762         if (board_config != ALC880_AUTO)
5763                 setup_preset(codec, &alc880_presets[board_config]);
5764
5765         spec->stream_analog_playback = &alc880_pcm_analog_playback;
5766         spec->stream_analog_capture = &alc880_pcm_analog_capture;
5767         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
5768
5769         spec->stream_digital_playback = &alc880_pcm_digital_playback;
5770         spec->stream_digital_capture = &alc880_pcm_digital_capture;
5771
5772         if (!spec->adc_nids && spec->input_mux) {
5773                 /* check whether NID 0x07 is valid */
5774                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
5775                 /* get type */
5776                 wcap = get_wcaps_type(wcap);
5777                 if (wcap != AC_WID_AUD_IN) {
5778                         spec->adc_nids = alc880_adc_nids_alt;
5779                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
5780                 } else {
5781                         spec->adc_nids = alc880_adc_nids;
5782                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
5783                 }
5784         }
5785         set_capture_mixer(codec);
5786         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5787
5788         spec->vmaster_nid = 0x0c;
5789
5790         codec->patch_ops = alc_patch_ops;
5791         if (board_config == ALC880_AUTO)
5792                 spec->init_hook = alc880_auto_init;
5793 #ifdef CONFIG_SND_HDA_POWER_SAVE
5794         if (!spec->loopback.amplist)
5795                 spec->loopback.amplist = alc880_loopbacks;
5796 #endif
5797
5798         return 0;
5799 }
5800
5801
5802 /*
5803  * ALC260 support
5804  */
5805
5806 static hda_nid_t alc260_dac_nids[1] = {
5807         /* front */
5808         0x02,
5809 };
5810
5811 static hda_nid_t alc260_adc_nids[1] = {
5812         /* ADC0 */
5813         0x04,
5814 };
5815
5816 static hda_nid_t alc260_adc_nids_alt[1] = {
5817         /* ADC1 */
5818         0x05,
5819 };
5820
5821 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5822  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5823  */
5824 static hda_nid_t alc260_dual_adc_nids[2] = {
5825         /* ADC0, ADC1 */
5826         0x04, 0x05
5827 };
5828
5829 #define ALC260_DIGOUT_NID       0x03
5830 #define ALC260_DIGIN_NID        0x06
5831
5832 static struct hda_input_mux alc260_capture_source = {
5833         .num_items = 4,
5834         .items = {
5835                 { "Mic", 0x0 },
5836                 { "Front Mic", 0x1 },
5837                 { "Line", 0x2 },
5838                 { "CD", 0x4 },
5839         },
5840 };
5841
5842 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5843  * headphone jack and the internal CD lines since these are the only pins at
5844  * which audio can appear.  For flexibility, also allow the option of
5845  * recording the mixer output on the second ADC (ADC0 doesn't have a
5846  * connection to the mixer output).
5847  */
5848 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5849         {
5850                 .num_items = 3,
5851                 .items = {
5852                         { "Mic/Line", 0x0 },
5853                         { "CD", 0x4 },
5854                         { "Headphone", 0x2 },
5855                 },
5856         },
5857         {
5858                 .num_items = 4,
5859                 .items = {
5860                         { "Mic/Line", 0x0 },
5861                         { "CD", 0x4 },
5862                         { "Headphone", 0x2 },
5863                         { "Mixer", 0x5 },
5864                 },
5865         },
5866
5867 };
5868
5869 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5870  * the Fujitsu S702x, but jacks are marked differently.
5871  */
5872 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5873         {
5874                 .num_items = 4,
5875                 .items = {
5876                         { "Mic", 0x0 },
5877                         { "Line", 0x2 },
5878                         { "CD", 0x4 },
5879                         { "Headphone", 0x5 },
5880                 },
5881         },
5882         {
5883                 .num_items = 5,
5884                 .items = {
5885                         { "Mic", 0x0 },
5886                         { "Line", 0x2 },
5887                         { "CD", 0x4 },
5888                         { "Headphone", 0x6 },
5889                         { "Mixer", 0x5 },
5890                 },
5891         },
5892 };
5893
5894 /* Maxdata Favorit 100XS */
5895 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5896         {
5897                 .num_items = 2,
5898                 .items = {
5899                         { "Line/Mic", 0x0 },
5900                         { "CD", 0x4 },
5901                 },
5902         },
5903         {
5904                 .num_items = 3,
5905                 .items = {
5906                         { "Line/Mic", 0x0 },
5907                         { "CD", 0x4 },
5908                         { "Mixer", 0x5 },
5909                 },
5910         },
5911 };
5912
5913 /*
5914  * This is just place-holder, so there's something for alc_build_pcms to look
5915  * at when it calculates the maximum number of channels. ALC260 has no mixer
5916  * element which allows changing the channel mode, so the verb list is
5917  * never used.
5918  */
5919 static struct hda_channel_mode alc260_modes[1] = {
5920         { 2, NULL },
5921 };
5922
5923
5924 /* Mixer combinations
5925  *
5926  * basic: base_output + input + pc_beep + capture
5927  * HP: base_output + input + capture_alt
5928  * HP_3013: hp_3013 + input + capture
5929  * fujitsu: fujitsu + capture
5930  * acer: acer + capture
5931  */
5932
5933 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5934         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5935         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5936         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5937         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5938         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5939         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5940         { } /* end */
5941 };
5942
5943 static struct snd_kcontrol_new alc260_input_mixer[] = {
5944         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5945         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5946         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5947         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5948         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5949         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5950         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5951         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5952         { } /* end */
5953 };
5954
5955 /* update HP, line and mono out pins according to the master switch */
5956 static void alc260_hp_master_update(struct hda_codec *codec,
5957                                     hda_nid_t hp, hda_nid_t line,
5958                                     hda_nid_t mono)
5959 {
5960         struct alc_spec *spec = codec->spec;
5961         unsigned int val = spec->master_sw ? PIN_HP : 0;
5962         /* change HP and line-out pins */
5963         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5964                             val);
5965         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5966                             val);
5967         /* mono (speaker) depending on the HP jack sense */
5968         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5969         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5970                             val);
5971 }
5972
5973 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5974                                    struct snd_ctl_elem_value *ucontrol)
5975 {
5976         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5977         struct alc_spec *spec = codec->spec;
5978         *ucontrol->value.integer.value = spec->master_sw;
5979         return 0;
5980 }
5981
5982 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5983                                    struct snd_ctl_elem_value *ucontrol)
5984 {
5985         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5986         struct alc_spec *spec = codec->spec;
5987         int val = !!*ucontrol->value.integer.value;
5988         hda_nid_t hp, line, mono;
5989
5990         if (val == spec->master_sw)
5991                 return 0;
5992         spec->master_sw = val;
5993         hp = (kcontrol->private_value >> 16) & 0xff;
5994         line = (kcontrol->private_value >> 8) & 0xff;
5995         mono = kcontrol->private_value & 0xff;
5996         alc260_hp_master_update(codec, hp, line, mono);
5997         return 1;
5998 }
5999
6000 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
6001         {
6002                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6003                 .name = "Master Playback Switch",
6004                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
6005                 .info = snd_ctl_boolean_mono_info,
6006                 .get = alc260_hp_master_sw_get,
6007                 .put = alc260_hp_master_sw_put,
6008                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
6009         },
6010         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6011         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
6012         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6013         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
6014         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
6015                               HDA_OUTPUT),
6016         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6017         { } /* end */
6018 };
6019
6020 static struct hda_verb alc260_hp_unsol_verbs[] = {
6021         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6022         {},
6023 };
6024
6025 static void alc260_hp_automute(struct hda_codec *codec)
6026 {
6027         struct alc_spec *spec = codec->spec;
6028
6029         spec->jack_present = snd_hda_jack_detect(codec, 0x10);
6030         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
6031 }
6032
6033 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
6034 {
6035         if ((res >> 26) == ALC880_HP_EVENT)
6036                 alc260_hp_automute(codec);
6037 }
6038
6039 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
6040         {
6041                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6042                 .name = "Master Playback Switch",
6043                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
6044                 .info = snd_ctl_boolean_mono_info,
6045                 .get = alc260_hp_master_sw_get,
6046                 .put = alc260_hp_master_sw_put,
6047                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
6048         },
6049         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6050         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
6051         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
6052         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
6053         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6054         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6055         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6056         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
6057         { } /* end */
6058 };
6059
6060 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
6061         .ops = &snd_hda_bind_vol,
6062         .values = {
6063                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
6064                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
6065                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
6066                 0
6067         },
6068 };
6069
6070 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
6071         .ops = &snd_hda_bind_sw,
6072         .values = {
6073                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
6074                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
6075                 0
6076         },
6077 };
6078
6079 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
6080         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
6081         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
6082         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
6083         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
6084         { } /* end */
6085 };
6086
6087 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
6088         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6089         {},
6090 };
6091
6092 static void alc260_hp_3013_automute(struct hda_codec *codec)
6093 {
6094         struct alc_spec *spec = codec->spec;
6095
6096         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
6097         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
6098 }
6099
6100 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
6101                                        unsigned int res)
6102 {
6103         if ((res >> 26) == ALC880_HP_EVENT)
6104                 alc260_hp_3013_automute(codec);
6105 }
6106
6107 static void alc260_hp_3012_automute(struct hda_codec *codec)
6108 {
6109         unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
6110
6111         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6112                             bits);
6113         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6114                             bits);
6115         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6116                             bits);
6117 }
6118
6119 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
6120                                        unsigned int res)
6121 {
6122         if ((res >> 26) == ALC880_HP_EVENT)
6123                 alc260_hp_3012_automute(codec);
6124 }
6125
6126 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
6127  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
6128  */
6129 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
6130         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6131         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
6132         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6133         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6134         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6135         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
6136         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
6137         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
6138         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6139         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
6140         { } /* end */
6141 };
6142
6143 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
6144  * versions of the ALC260 don't act on requests to enable mic bias from NID
6145  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
6146  * datasheet doesn't mention this restriction.  At this stage it's not clear
6147  * whether this behaviour is intentional or is a hardware bug in chip
6148  * revisions available in early 2006.  Therefore for now allow the
6149  * "Headphone Jack Mode" control to span all choices, but if it turns out
6150  * that the lack of mic bias for this NID is intentional we could change the
6151  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6152  *
6153  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
6154  * don't appear to make the mic bias available from the "line" jack, even
6155  * though the NID used for this jack (0x14) can supply it.  The theory is
6156  * that perhaps Acer have included blocking capacitors between the ALC260
6157  * and the output jack.  If this turns out to be the case for all such
6158  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
6159  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
6160  *
6161  * The C20x Tablet series have a mono internal speaker which is controlled
6162  * via the chip's Mono sum widget and pin complex, so include the necessary
6163  * controls for such models.  On models without a "mono speaker" the control
6164  * won't do anything.
6165  */
6166 static struct snd_kcontrol_new alc260_acer_mixer[] = {
6167         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6168         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6169         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6170         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
6171                               HDA_OUTPUT),
6172         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
6173                            HDA_INPUT),
6174         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6175         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6176         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6177         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6178         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6179         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6180         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6181         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6182         { } /* end */
6183 };
6184
6185 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
6186  */
6187 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
6188         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6189         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6190         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6191         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6192         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6193         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6194         { } /* end */
6195 };
6196
6197 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
6198  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
6199  */
6200 static struct snd_kcontrol_new alc260_will_mixer[] = {
6201         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6202         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6203         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6204         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6205         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6206         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6207         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6208         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6209         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6210         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6211         { } /* end */
6212 };
6213
6214 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
6215  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
6216  */
6217 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
6218         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6219         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6220         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6221         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6222         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6223         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
6224         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
6225         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6226         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6227         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6228         { } /* end */
6229 };
6230
6231 /*
6232  * initialization verbs
6233  */
6234 static struct hda_verb alc260_init_verbs[] = {
6235         /* Line In pin widget for input */
6236         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6237         /* CD pin widget for input */
6238         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6239         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6240         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6241         /* Mic2 (front panel) pin widget for input and vref at 80% */
6242         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6243         /* LINE-2 is used for line-out in rear */
6244         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6245         /* select line-out */
6246         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
6247         /* LINE-OUT pin */
6248         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6249         /* enable HP */
6250         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6251         /* enable Mono */
6252         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6253         /* mute capture amp left and right */
6254         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6255         /* set connection select to line in (default select for this ADC) */
6256         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6257         /* mute capture amp left and right */
6258         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6259         /* set connection select to line in (default select for this ADC) */
6260         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
6261         /* set vol=0 Line-Out mixer amp left and right */
6262         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6263         /* unmute pin widget amp left and right (no gain on this amp) */
6264         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6265         /* set vol=0 HP mixer amp left and right */
6266         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6267         /* unmute pin widget amp left and right (no gain on this amp) */
6268         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6269         /* set vol=0 Mono mixer amp left and right */
6270         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6271         /* unmute pin widget amp left and right (no gain on this amp) */
6272         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6273         /* unmute LINE-2 out pin */
6274         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6275         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6276          * Line In 2 = 0x03
6277          */
6278         /* mute analog inputs */
6279         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6280         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6281         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6282         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6283         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6284         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6285         /* mute Front out path */
6286         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6287         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6288         /* mute Headphone out path */
6289         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6290         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6291         /* mute Mono out path */
6292         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6293         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6294         { }
6295 };
6296
6297 #if 0 /* should be identical with alc260_init_verbs? */
6298 static struct hda_verb alc260_hp_init_verbs[] = {
6299         /* Headphone and output */
6300         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6301         /* mono output */
6302         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6303         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6304         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6305         /* Mic2 (front panel) pin widget for input and vref at 80% */
6306         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6307         /* Line In pin widget for input */
6308         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6309         /* Line-2 pin widget for output */
6310         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6311         /* CD pin widget for input */
6312         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6313         /* unmute amp left and right */
6314         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6315         /* set connection select to line in (default select for this ADC) */
6316         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6317         /* unmute Line-Out mixer amp left and right (volume = 0) */
6318         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6319         /* mute pin widget amp left and right (no gain on this amp) */
6320         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6321         /* unmute HP mixer amp left and right (volume = 0) */
6322         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6323         /* mute pin widget amp left and right (no gain on this amp) */
6324         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6325         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6326          * Line In 2 = 0x03
6327          */
6328         /* mute analog inputs */
6329         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6330         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6331         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6332         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6333         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6334         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6335         /* Unmute Front out path */
6336         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6337         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6338         /* Unmute Headphone out path */
6339         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6340         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6341         /* Unmute Mono out path */
6342         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6343         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6344         { }
6345 };
6346 #endif
6347
6348 static struct hda_verb alc260_hp_3013_init_verbs[] = {
6349         /* Line out and output */
6350         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6351         /* mono output */
6352         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6353         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6354         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6355         /* Mic2 (front panel) pin widget for input and vref at 80% */
6356         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6357         /* Line In pin widget for input */
6358         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6359         /* Headphone pin widget for output */
6360         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6361         /* CD pin widget for input */
6362         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6363         /* unmute amp left and right */
6364         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6365         /* set connection select to line in (default select for this ADC) */
6366         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6367         /* unmute Line-Out mixer amp left and right (volume = 0) */
6368         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6369         /* mute pin widget amp left and right (no gain on this amp) */
6370         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6371         /* unmute HP mixer amp left and right (volume = 0) */
6372         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6373         /* mute pin widget amp left and right (no gain on this amp) */
6374         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6375         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6376          * Line In 2 = 0x03
6377          */
6378         /* mute analog inputs */
6379         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6380         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6381         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6382         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6383         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6384         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6385         /* Unmute Front out path */
6386         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6387         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6388         /* Unmute Headphone out path */
6389         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6390         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6391         /* Unmute Mono out path */
6392         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6393         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6394         { }
6395 };
6396
6397 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
6398  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
6399  * audio = 0x16, internal speaker = 0x10.
6400  */
6401 static struct hda_verb alc260_fujitsu_init_verbs[] = {
6402         /* Disable all GPIOs */
6403         {0x01, AC_VERB_SET_GPIO_MASK, 0},
6404         /* Internal speaker is connected to headphone pin */
6405         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6406         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
6407         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6408         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
6409         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6410         /* Ensure all other unused pins are disabled and muted. */
6411         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6412         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6413         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6414         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6415         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6416         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6417         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6418         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6419
6420         /* Disable digital (SPDIF) pins */
6421         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6422         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6423
6424         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
6425          * when acting as an output.
6426          */
6427         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6428
6429         /* Start with output sum widgets muted and their output gains at min */
6430         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6431         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6432         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6433         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6434         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6435         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6436         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6437         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6438         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6439
6440         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
6441         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6442         /* Unmute Line1 pin widget output buffer since it starts as an output.
6443          * If the pin mode is changed by the user the pin mode control will
6444          * take care of enabling the pin's input/output buffers as needed.
6445          * Therefore there's no need to enable the input buffer at this
6446          * stage.
6447          */
6448         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6449         /* Unmute input buffer of pin widget used for Line-in (no equiv
6450          * mixer ctrl)
6451          */
6452         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6453
6454         /* Mute capture amp left and right */
6455         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6456         /* Set ADC connection select to match default mixer setting - line
6457          * in (on mic1 pin)
6458          */
6459         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6460
6461         /* Do the same for the second ADC: mute capture input amp and
6462          * set ADC connection to line in (on mic1 pin)
6463          */
6464         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6465         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6466
6467         /* Mute all inputs to mixer widget (even unconnected ones) */
6468         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6469         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6470         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6471         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6472         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6473         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6474         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6475         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6476
6477         { }
6478 };
6479
6480 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
6481  * similar laptops (adapted from Fujitsu init verbs).
6482  */
6483 static struct hda_verb alc260_acer_init_verbs[] = {
6484         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
6485          * the headphone jack.  Turn this on and rely on the standard mute
6486          * methods whenever the user wants to turn these outputs off.
6487          */
6488         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6489         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6490         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6491         /* Internal speaker/Headphone jack is connected to Line-out pin */
6492         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6493         /* Internal microphone/Mic jack is connected to Mic1 pin */
6494         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6495         /* Line In jack is connected to Line1 pin */
6496         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6497         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
6498         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6499         /* Ensure all other unused pins are disabled and muted. */
6500         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6501         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6502         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6503         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6504         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6505         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6506         /* Disable digital (SPDIF) pins */
6507         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6508         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6509
6510         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6511          * bus when acting as outputs.
6512          */
6513         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6514         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6515
6516         /* Start with output sum widgets muted and their output gains at min */
6517         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6518         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6519         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6520         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6521         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6522         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6523         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6524         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6525         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6526
6527         /* Unmute Line-out pin widget amp left and right
6528          * (no equiv mixer ctrl)
6529          */
6530         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6531         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
6532         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6533         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6534          * inputs. If the pin mode is changed by the user the pin mode control
6535          * will take care of enabling the pin's input/output buffers as needed.
6536          * Therefore there's no need to enable the input buffer at this
6537          * stage.
6538          */
6539         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6540         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6541
6542         /* Mute capture amp left and right */
6543         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6544         /* Set ADC connection select to match default mixer setting - mic
6545          * (on mic1 pin)
6546          */
6547         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6548
6549         /* Do similar with the second ADC: mute capture input amp and
6550          * set ADC connection to mic to match ALSA's default state.
6551          */
6552         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6553         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6554
6555         /* Mute all inputs to mixer widget (even unconnected ones) */
6556         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6557         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6558         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6559         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6560         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6561         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6562         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6563         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6564
6565         { }
6566 };
6567
6568 /* Initialisation sequence for Maxdata Favorit 100XS
6569  * (adapted from Acer init verbs).
6570  */
6571 static struct hda_verb alc260_favorit100_init_verbs[] = {
6572         /* GPIO 0 enables the output jack.
6573          * Turn this on and rely on the standard mute
6574          * methods whenever the user wants to turn these outputs off.
6575          */
6576         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6577         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6578         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6579         /* Line/Mic input jack is connected to Mic1 pin */
6580         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6581         /* Ensure all other unused pins are disabled and muted. */
6582         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6583         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6584         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6585         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6586         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6587         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6588         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6589         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6590         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6591         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6592         /* Disable digital (SPDIF) pins */
6593         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6594         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6595
6596         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6597          * bus when acting as outputs.
6598          */
6599         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6600         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6601
6602         /* Start with output sum widgets muted and their output gains at min */
6603         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6604         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6605         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6606         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6607         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6608         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6609         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6610         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6611         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6612
6613         /* Unmute Line-out pin widget amp left and right
6614          * (no equiv mixer ctrl)
6615          */
6616         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6617         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6618          * inputs. If the pin mode is changed by the user the pin mode control
6619          * will take care of enabling the pin's input/output buffers as needed.
6620          * Therefore there's no need to enable the input buffer at this
6621          * stage.
6622          */
6623         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6624
6625         /* Mute capture amp left and right */
6626         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6627         /* Set ADC connection select to match default mixer setting - mic
6628          * (on mic1 pin)
6629          */
6630         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6631
6632         /* Do similar with the second ADC: mute capture input amp and
6633          * set ADC connection to mic to match ALSA's default state.
6634          */
6635         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6636         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6637
6638         /* Mute all inputs to mixer widget (even unconnected ones) */
6639         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6640         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6641         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6642         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6643         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6644         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6645         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6646         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6647
6648         { }
6649 };
6650
6651 static struct hda_verb alc260_will_verbs[] = {
6652         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6653         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6654         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6655         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6656         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6657         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6658         {}
6659 };
6660
6661 static struct hda_verb alc260_replacer_672v_verbs[] = {
6662         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6663         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6664         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6665
6666         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6667         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6668         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6669
6670         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6671         {}
6672 };
6673
6674 /* toggle speaker-output according to the hp-jack state */
6675 static void alc260_replacer_672v_automute(struct hda_codec *codec)
6676 {
6677         unsigned int present;
6678
6679         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6680         present = snd_hda_jack_detect(codec, 0x0f);
6681         if (present) {
6682                 snd_hda_codec_write_cache(codec, 0x01, 0,
6683                                           AC_VERB_SET_GPIO_DATA, 1);
6684                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6685                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6686                                           PIN_HP);
6687         } else {
6688                 snd_hda_codec_write_cache(codec, 0x01, 0,
6689                                           AC_VERB_SET_GPIO_DATA, 0);
6690                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6691                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6692                                           PIN_OUT);
6693         }
6694 }
6695
6696 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6697                                        unsigned int res)
6698 {
6699         if ((res >> 26) == ALC880_HP_EVENT)
6700                 alc260_replacer_672v_automute(codec);
6701 }
6702
6703 static struct hda_verb alc260_hp_dc7600_verbs[] = {
6704         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6705         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6706         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6707         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6708         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6709         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6710         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6711         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6712         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6713         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6714         {}
6715 };
6716
6717 /* Test configuration for debugging, modelled after the ALC880 test
6718  * configuration.
6719  */
6720 #ifdef CONFIG_SND_DEBUG
6721 static hda_nid_t alc260_test_dac_nids[1] = {
6722         0x02,
6723 };
6724 static hda_nid_t alc260_test_adc_nids[2] = {
6725         0x04, 0x05,
6726 };
6727 /* For testing the ALC260, each input MUX needs its own definition since
6728  * the signal assignments are different.  This assumes that the first ADC
6729  * is NID 0x04.
6730  */
6731 static struct hda_input_mux alc260_test_capture_sources[2] = {
6732         {
6733                 .num_items = 7,
6734                 .items = {
6735                         { "MIC1 pin", 0x0 },
6736                         { "MIC2 pin", 0x1 },
6737                         { "LINE1 pin", 0x2 },
6738                         { "LINE2 pin", 0x3 },
6739                         { "CD pin", 0x4 },
6740                         { "LINE-OUT pin", 0x5 },
6741                         { "HP-OUT pin", 0x6 },
6742                 },
6743         },
6744         {
6745                 .num_items = 8,
6746                 .items = {
6747                         { "MIC1 pin", 0x0 },
6748                         { "MIC2 pin", 0x1 },
6749                         { "LINE1 pin", 0x2 },
6750                         { "LINE2 pin", 0x3 },
6751                         { "CD pin", 0x4 },
6752                         { "Mixer", 0x5 },
6753                         { "LINE-OUT pin", 0x6 },
6754                         { "HP-OUT pin", 0x7 },
6755                 },
6756         },
6757 };
6758 static struct snd_kcontrol_new alc260_test_mixer[] = {
6759         /* Output driver widgets */
6760         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6761         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6762         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6763         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6764         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6765         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6766
6767         /* Modes for retasking pin widgets
6768          * Note: the ALC260 doesn't seem to act on requests to enable mic
6769          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6770          * mention this restriction.  At this stage it's not clear whether
6771          * this behaviour is intentional or is a hardware bug in chip
6772          * revisions available at least up until early 2006.  Therefore for
6773          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6774          * choices, but if it turns out that the lack of mic bias for these
6775          * NIDs is intentional we could change their modes from
6776          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6777          */
6778         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6779         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6780         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
6781         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
6782         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
6783         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
6784
6785         /* Loopback mixer controls */
6786         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
6787         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
6788         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
6789         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
6790         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
6791         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
6792         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
6793         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
6794         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6795         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6796         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
6797         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
6798         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
6799         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
6800
6801         /* Controls for GPIO pins, assuming they are configured as outputs */
6802         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
6803         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
6804         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
6805         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
6806
6807         /* Switches to allow the digital IO pins to be enabled.  The datasheet
6808          * is ambigious as to which NID is which; testing on laptops which
6809          * make this output available should provide clarification.
6810          */
6811         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
6812         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
6813
6814         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
6815          * this output to turn on an external amplifier.
6816          */
6817         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
6818         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
6819
6820         { } /* end */
6821 };
6822 static struct hda_verb alc260_test_init_verbs[] = {
6823         /* Enable all GPIOs as outputs with an initial value of 0 */
6824         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6825         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6826         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6827
6828         /* Enable retasking pins as output, initially without power amp */
6829         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6830         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6831         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6832         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6833         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6834         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6835
6836         /* Disable digital (SPDIF) pins initially, but users can enable
6837          * them via a mixer switch.  In the case of SPDIF-out, this initverb
6838          * payload also sets the generation to 0, output to be in "consumer"
6839          * PCM format, copyright asserted, no pre-emphasis and no validity
6840          * control.
6841          */
6842         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6843         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6844
6845         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6846          * OUT1 sum bus when acting as an output.
6847          */
6848         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6849         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6850         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6851         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6852
6853         /* Start with output sum widgets muted and their output gains at min */
6854         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6855         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6856         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6857         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6858         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6859         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6860         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6861         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6862         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6863
6864         /* Unmute retasking pin widget output buffers since the default
6865          * state appears to be output.  As the pin mode is changed by the
6866          * user the pin mode control will take care of enabling the pin's
6867          * input/output buffers as needed.
6868          */
6869         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6870         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6871         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6872         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6873         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6874         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6875         /* Also unmute the mono-out pin widget */
6876         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6877
6878         /* Mute capture amp left and right */
6879         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6880         /* Set ADC connection select to match default mixer setting (mic1
6881          * pin)
6882          */
6883         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6884
6885         /* Do the same for the second ADC: mute capture input amp and
6886          * set ADC connection to mic1 pin
6887          */
6888         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6889         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6890
6891         /* Mute all inputs to mixer widget (even unconnected ones) */
6892         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6893         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6894         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6895         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6896         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6897         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6898         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6899         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6900
6901         { }
6902 };
6903 #endif
6904
6905 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
6906 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
6907
6908 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
6909 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
6910
6911 /*
6912  * for BIOS auto-configuration
6913  */
6914
6915 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6916                                         const char *pfx, int *vol_bits)
6917 {
6918         hda_nid_t nid_vol;
6919         unsigned long vol_val, sw_val;
6920         int err;
6921
6922         if (nid >= 0x0f && nid < 0x11) {
6923                 nid_vol = nid - 0x7;
6924                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6925                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6926         } else if (nid == 0x11) {
6927                 nid_vol = nid - 0x7;
6928                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6929                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6930         } else if (nid >= 0x12 && nid <= 0x15) {
6931                 nid_vol = 0x08;
6932                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6933                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6934         } else
6935                 return 0; /* N/A */
6936
6937         if (!(*vol_bits & (1 << nid_vol))) {
6938                 /* first control for the volume widget */
6939                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6940                 if (err < 0)
6941                         return err;
6942                 *vol_bits |= (1 << nid_vol);
6943         }
6944         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6945         if (err < 0)
6946                 return err;
6947         return 1;
6948 }
6949
6950 /* add playback controls from the parsed DAC table */
6951 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6952                                              const struct auto_pin_cfg *cfg)
6953 {
6954         hda_nid_t nid;
6955         int err;
6956         int vols = 0;
6957
6958         spec->multiout.num_dacs = 1;
6959         spec->multiout.dac_nids = spec->private_dac_nids;
6960         spec->multiout.dac_nids[0] = 0x02;
6961
6962         nid = cfg->line_out_pins[0];
6963         if (nid) {
6964                 const char *pfx;
6965                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6966                         pfx = "Master";
6967                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6968                         pfx = "Speaker";
6969                 else
6970                         pfx = "Front";
6971                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6972                 if (err < 0)
6973                         return err;
6974         }
6975
6976         nid = cfg->speaker_pins[0];
6977         if (nid) {
6978                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6979                 if (err < 0)
6980                         return err;
6981         }
6982
6983         nid = cfg->hp_pins[0];
6984         if (nid) {
6985                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6986                                                    &vols);
6987                 if (err < 0)
6988                         return err;
6989         }
6990         return 0;
6991 }
6992
6993 /* create playback/capture controls for input pins */
6994 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6995                                                 const struct auto_pin_cfg *cfg)
6996 {
6997         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6998 }
6999
7000 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
7001                                               hda_nid_t nid, int pin_type,
7002                                               int sel_idx)
7003 {
7004         alc_set_pin_output(codec, nid, pin_type);
7005         /* need the manual connection? */
7006         if (nid >= 0x12) {
7007                 int idx = nid - 0x12;
7008                 snd_hda_codec_write(codec, idx + 0x0b, 0,
7009                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
7010         }
7011 }
7012
7013 static void alc260_auto_init_multi_out(struct hda_codec *codec)
7014 {
7015         struct alc_spec *spec = codec->spec;
7016         hda_nid_t nid;
7017
7018         nid = spec->autocfg.line_out_pins[0];
7019         if (nid) {
7020                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
7021                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
7022         }
7023
7024         nid = spec->autocfg.speaker_pins[0];
7025         if (nid)
7026                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
7027
7028         nid = spec->autocfg.hp_pins[0];
7029         if (nid)
7030                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
7031 }
7032
7033 #define ALC260_PIN_CD_NID               0x16
7034 static void alc260_auto_init_analog_input(struct hda_codec *codec)
7035 {
7036         struct alc_spec *spec = codec->spec;
7037         struct auto_pin_cfg *cfg = &spec->autocfg;
7038         int i;
7039
7040         for (i = 0; i < cfg->num_inputs; i++) {
7041                 hda_nid_t nid = cfg->inputs[i].pin;
7042                 if (nid >= 0x12) {
7043                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
7044                         if (nid != ALC260_PIN_CD_NID &&
7045                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
7046                                 snd_hda_codec_write(codec, nid, 0,
7047                                                     AC_VERB_SET_AMP_GAIN_MUTE,
7048                                                     AMP_OUT_MUTE);
7049                 }
7050         }
7051 }
7052
7053 #define alc260_auto_init_input_src      alc880_auto_init_input_src
7054
7055 /*
7056  * generic initialization of ADC, input mixers and output mixers
7057  */
7058 static struct hda_verb alc260_volume_init_verbs[] = {
7059         /*
7060          * Unmute ADC0-1 and set the default input to mic-in
7061          */
7062         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
7063         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7064         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
7065         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7066
7067         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7068          * mixer widget
7069          * Note: PASD motherboards uses the Line In 2 as the input for
7070          * front panel mic (mic 2)
7071          */
7072         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7073         /* mute analog inputs */
7074         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7075         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7076         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7077         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7078         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7079
7080         /*
7081          * Set up output mixers (0x08 - 0x0a)
7082          */
7083         /* set vol=0 to output mixers */
7084         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7085         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7086         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7087         /* set up input amps for analog loopback */
7088         /* Amp Indices: DAC = 0, mixer = 1 */
7089         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7090         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7091         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7092         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7093         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7094         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7095
7096         { }
7097 };
7098
7099 static int alc260_parse_auto_config(struct hda_codec *codec)
7100 {
7101         struct alc_spec *spec = codec->spec;
7102         int err;
7103         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
7104
7105         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
7106                                            alc260_ignore);
7107         if (err < 0)
7108                 return err;
7109         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
7110         if (err < 0)
7111                 return err;
7112         if (!spec->kctls.list)
7113                 return 0; /* can't find valid BIOS pin config */
7114         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
7115         if (err < 0)
7116                 return err;
7117
7118         spec->multiout.max_channels = 2;
7119
7120         if (spec->autocfg.dig_outs)
7121                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
7122         if (spec->kctls.list)
7123                 add_mixer(spec, spec->kctls.list);
7124
7125         add_verb(spec, alc260_volume_init_verbs);
7126
7127         spec->num_mux_defs = 1;
7128         spec->input_mux = &spec->private_imux[0];
7129
7130         alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
7131
7132         return 1;
7133 }
7134
7135 /* additional initialization for auto-configuration model */
7136 static void alc260_auto_init(struct hda_codec *codec)
7137 {
7138         struct alc_spec *spec = codec->spec;
7139         alc260_auto_init_multi_out(codec);
7140         alc260_auto_init_analog_input(codec);
7141         alc260_auto_init_input_src(codec);
7142         alc_auto_init_digital(codec);
7143         if (spec->unsol_event)
7144                 alc_inithook(codec);
7145 }
7146
7147 #ifdef CONFIG_SND_HDA_POWER_SAVE
7148 static struct hda_amp_list alc260_loopbacks[] = {
7149         { 0x07, HDA_INPUT, 0 },
7150         { 0x07, HDA_INPUT, 1 },
7151         { 0x07, HDA_INPUT, 2 },
7152         { 0x07, HDA_INPUT, 3 },
7153         { 0x07, HDA_INPUT, 4 },
7154         { } /* end */
7155 };
7156 #endif
7157
7158 /*
7159  * Pin config fixes
7160  */
7161 enum {
7162         PINFIX_HP_DC5750,
7163 };
7164
7165 static const struct alc_fixup alc260_fixups[] = {
7166         [PINFIX_HP_DC5750] = {
7167                 .type = ALC_FIXUP_PINS,
7168                 .v.pins = (const struct alc_pincfg[]) {
7169                         { 0x11, 0x90130110 }, /* speaker */
7170                         { }
7171                 }
7172         },
7173 };
7174
7175 static struct snd_pci_quirk alc260_fixup_tbl[] = {
7176         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
7177         {}
7178 };
7179
7180 /*
7181  * ALC260 configurations
7182  */
7183 static const char * const alc260_models[ALC260_MODEL_LAST] = {
7184         [ALC260_BASIC]          = "basic",
7185         [ALC260_HP]             = "hp",
7186         [ALC260_HP_3013]        = "hp-3013",
7187         [ALC260_HP_DC7600]      = "hp-dc7600",
7188         [ALC260_FUJITSU_S702X]  = "fujitsu",
7189         [ALC260_ACER]           = "acer",
7190         [ALC260_WILL]           = "will",
7191         [ALC260_REPLACER_672V]  = "replacer",
7192         [ALC260_FAVORIT100]     = "favorit100",
7193 #ifdef CONFIG_SND_DEBUG
7194         [ALC260_TEST]           = "test",
7195 #endif
7196         [ALC260_AUTO]           = "auto",
7197 };
7198
7199 static struct snd_pci_quirk alc260_cfg_tbl[] = {
7200         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
7201         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
7202         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
7203         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
7204         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
7205         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
7206         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
7207         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
7208         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
7209         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
7210         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
7211         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
7212         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
7213         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
7214         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
7215         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
7216         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
7217         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
7218         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
7219         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
7220         {}
7221 };
7222
7223 static struct alc_config_preset alc260_presets[] = {
7224         [ALC260_BASIC] = {
7225                 .mixers = { alc260_base_output_mixer,
7226                             alc260_input_mixer },
7227                 .init_verbs = { alc260_init_verbs },
7228                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7229                 .dac_nids = alc260_dac_nids,
7230                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7231                 .adc_nids = alc260_dual_adc_nids,
7232                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7233                 .channel_mode = alc260_modes,
7234                 .input_mux = &alc260_capture_source,
7235         },
7236         [ALC260_HP] = {
7237                 .mixers = { alc260_hp_output_mixer,
7238                             alc260_input_mixer },
7239                 .init_verbs = { alc260_init_verbs,
7240                                 alc260_hp_unsol_verbs },
7241                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7242                 .dac_nids = alc260_dac_nids,
7243                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7244                 .adc_nids = alc260_adc_nids_alt,
7245                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7246                 .channel_mode = alc260_modes,
7247                 .input_mux = &alc260_capture_source,
7248                 .unsol_event = alc260_hp_unsol_event,
7249                 .init_hook = alc260_hp_automute,
7250         },
7251         [ALC260_HP_DC7600] = {
7252                 .mixers = { alc260_hp_dc7600_mixer,
7253                             alc260_input_mixer },
7254                 .init_verbs = { alc260_init_verbs,
7255                                 alc260_hp_dc7600_verbs },
7256                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7257                 .dac_nids = alc260_dac_nids,
7258                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7259                 .adc_nids = alc260_adc_nids_alt,
7260                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7261                 .channel_mode = alc260_modes,
7262                 .input_mux = &alc260_capture_source,
7263                 .unsol_event = alc260_hp_3012_unsol_event,
7264                 .init_hook = alc260_hp_3012_automute,
7265         },
7266         [ALC260_HP_3013] = {
7267                 .mixers = { alc260_hp_3013_mixer,
7268                             alc260_input_mixer },
7269                 .init_verbs = { alc260_hp_3013_init_verbs,
7270                                 alc260_hp_3013_unsol_verbs },
7271                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7272                 .dac_nids = alc260_dac_nids,
7273                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7274                 .adc_nids = alc260_adc_nids_alt,
7275                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7276                 .channel_mode = alc260_modes,
7277                 .input_mux = &alc260_capture_source,
7278                 .unsol_event = alc260_hp_3013_unsol_event,
7279                 .init_hook = alc260_hp_3013_automute,
7280         },
7281         [ALC260_FUJITSU_S702X] = {
7282                 .mixers = { alc260_fujitsu_mixer },
7283                 .init_verbs = { alc260_fujitsu_init_verbs },
7284                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7285                 .dac_nids = alc260_dac_nids,
7286                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7287                 .adc_nids = alc260_dual_adc_nids,
7288                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7289                 .channel_mode = alc260_modes,
7290                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
7291                 .input_mux = alc260_fujitsu_capture_sources,
7292         },
7293         [ALC260_ACER] = {
7294                 .mixers = { alc260_acer_mixer },
7295                 .init_verbs = { alc260_acer_init_verbs },
7296                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7297                 .dac_nids = alc260_dac_nids,
7298                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7299                 .adc_nids = alc260_dual_adc_nids,
7300                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7301                 .channel_mode = alc260_modes,
7302                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
7303                 .input_mux = alc260_acer_capture_sources,
7304         },
7305         [ALC260_FAVORIT100] = {
7306                 .mixers = { alc260_favorit100_mixer },
7307                 .init_verbs = { alc260_favorit100_init_verbs },
7308                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7309                 .dac_nids = alc260_dac_nids,
7310                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7311                 .adc_nids = alc260_dual_adc_nids,
7312                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7313                 .channel_mode = alc260_modes,
7314                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
7315                 .input_mux = alc260_favorit100_capture_sources,
7316         },
7317         [ALC260_WILL] = {
7318                 .mixers = { alc260_will_mixer },
7319                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
7320                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7321                 .dac_nids = alc260_dac_nids,
7322                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7323                 .adc_nids = alc260_adc_nids,
7324                 .dig_out_nid = ALC260_DIGOUT_NID,
7325                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7326                 .channel_mode = alc260_modes,
7327                 .input_mux = &alc260_capture_source,
7328         },
7329         [ALC260_REPLACER_672V] = {
7330                 .mixers = { alc260_replacer_672v_mixer },
7331                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
7332                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7333                 .dac_nids = alc260_dac_nids,
7334                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7335                 .adc_nids = alc260_adc_nids,
7336                 .dig_out_nid = ALC260_DIGOUT_NID,
7337                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7338                 .channel_mode = alc260_modes,
7339                 .input_mux = &alc260_capture_source,
7340                 .unsol_event = alc260_replacer_672v_unsol_event,
7341                 .init_hook = alc260_replacer_672v_automute,
7342         },
7343 #ifdef CONFIG_SND_DEBUG
7344         [ALC260_TEST] = {
7345                 .mixers = { alc260_test_mixer },
7346                 .init_verbs = { alc260_test_init_verbs },
7347                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
7348                 .dac_nids = alc260_test_dac_nids,
7349                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
7350                 .adc_nids = alc260_test_adc_nids,
7351                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7352                 .channel_mode = alc260_modes,
7353                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
7354                 .input_mux = alc260_test_capture_sources,
7355         },
7356 #endif
7357 };
7358
7359 static int patch_alc260(struct hda_codec *codec)
7360 {
7361         struct alc_spec *spec;
7362         int err, board_config;
7363
7364         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7365         if (spec == NULL)
7366                 return -ENOMEM;
7367
7368         codec->spec = spec;
7369
7370         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
7371                                                   alc260_models,
7372                                                   alc260_cfg_tbl);
7373         if (board_config < 0) {
7374                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
7375                            codec->chip_name);
7376                 board_config = ALC260_AUTO;
7377         }
7378
7379         if (board_config == ALC260_AUTO) {
7380                 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
7381                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
7382         }
7383
7384         if (board_config == ALC260_AUTO) {
7385                 /* automatic parse from the BIOS config */
7386                 err = alc260_parse_auto_config(codec);
7387                 if (err < 0) {
7388                         alc_free(codec);
7389                         return err;
7390                 } else if (!err) {
7391                         printk(KERN_INFO
7392                                "hda_codec: Cannot set up configuration "
7393                                "from BIOS.  Using base mode...\n");
7394                         board_config = ALC260_BASIC;
7395                 }
7396         }
7397
7398         err = snd_hda_attach_beep_device(codec, 0x1);
7399         if (err < 0) {
7400                 alc_free(codec);
7401                 return err;
7402         }
7403
7404         if (board_config != ALC260_AUTO)
7405                 setup_preset(codec, &alc260_presets[board_config]);
7406
7407         spec->stream_analog_playback = &alc260_pcm_analog_playback;
7408         spec->stream_analog_capture = &alc260_pcm_analog_capture;
7409         spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
7410
7411         spec->stream_digital_playback = &alc260_pcm_digital_playback;
7412         spec->stream_digital_capture = &alc260_pcm_digital_capture;
7413
7414         if (!spec->adc_nids && spec->input_mux) {
7415                 /* check whether NID 0x04 is valid */
7416                 unsigned int wcap = get_wcaps(codec, 0x04);
7417                 wcap = get_wcaps_type(wcap);
7418                 /* get type */
7419                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
7420                         spec->adc_nids = alc260_adc_nids_alt;
7421                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
7422                 } else {
7423                         spec->adc_nids = alc260_adc_nids;
7424                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
7425                 }
7426         }
7427         set_capture_mixer(codec);
7428         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
7429
7430         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
7431
7432         spec->vmaster_nid = 0x08;
7433
7434         codec->patch_ops = alc_patch_ops;
7435         if (board_config == ALC260_AUTO)
7436                 spec->init_hook = alc260_auto_init;
7437 #ifdef CONFIG_SND_HDA_POWER_SAVE
7438         if (!spec->loopback.amplist)
7439                 spec->loopback.amplist = alc260_loopbacks;
7440 #endif
7441
7442         return 0;
7443 }
7444
7445
7446 /*
7447  * ALC882/883/885/888/889 support
7448  *
7449  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
7450  * configuration.  Each pin widget can choose any input DACs and a mixer.
7451  * Each ADC is connected from a mixer of all inputs.  This makes possible
7452  * 6-channel independent captures.
7453  *
7454  * In addition, an independent DAC for the multi-playback (not used in this
7455  * driver yet).
7456  */
7457 #define ALC882_DIGOUT_NID       0x06
7458 #define ALC882_DIGIN_NID        0x0a
7459 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
7460 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
7461 #define ALC1200_DIGOUT_NID      0x10
7462
7463
7464 static struct hda_channel_mode alc882_ch_modes[1] = {
7465         { 8, NULL }
7466 };
7467
7468 /* DACs */
7469 static hda_nid_t alc882_dac_nids[4] = {
7470         /* front, rear, clfe, rear_surr */
7471         0x02, 0x03, 0x04, 0x05
7472 };
7473 #define alc883_dac_nids         alc882_dac_nids
7474
7475 /* ADCs */
7476 #define alc882_adc_nids         alc880_adc_nids
7477 #define alc882_adc_nids_alt     alc880_adc_nids_alt
7478 #define alc883_adc_nids         alc882_adc_nids_alt
7479 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
7480 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
7481 #define alc889_adc_nids         alc880_adc_nids
7482
7483 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
7484 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
7485 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
7486 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7487 #define alc889_capsrc_nids      alc882_capsrc_nids
7488
7489 /* input MUX */
7490 /* FIXME: should be a matrix-type input source selection */
7491
7492 static struct hda_input_mux alc882_capture_source = {
7493         .num_items = 4,
7494         .items = {
7495                 { "Mic", 0x0 },
7496                 { "Front Mic", 0x1 },
7497                 { "Line", 0x2 },
7498                 { "CD", 0x4 },
7499         },
7500 };
7501
7502 #define alc883_capture_source   alc882_capture_source
7503
7504 static struct hda_input_mux alc889_capture_source = {
7505         .num_items = 3,
7506         .items = {
7507                 { "Front Mic", 0x0 },
7508                 { "Mic", 0x3 },
7509                 { "Line", 0x2 },
7510         },
7511 };
7512
7513 static struct hda_input_mux mb5_capture_source = {
7514         .num_items = 3,
7515         .items = {
7516                 { "Mic", 0x1 },
7517                 { "Line", 0x7 },
7518                 { "CD", 0x4 },
7519         },
7520 };
7521
7522 static struct hda_input_mux macmini3_capture_source = {
7523         .num_items = 2,
7524         .items = {
7525                 { "Line", 0x2 },
7526                 { "CD", 0x4 },
7527         },
7528 };
7529
7530 static struct hda_input_mux alc883_3stack_6ch_intel = {
7531         .num_items = 4,
7532         .items = {
7533                 { "Mic", 0x1 },
7534                 { "Front Mic", 0x0 },
7535                 { "Line", 0x2 },
7536                 { "CD", 0x4 },
7537         },
7538 };
7539
7540 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7541         .num_items = 2,
7542         .items = {
7543                 { "Mic", 0x1 },
7544                 { "Line", 0x2 },
7545         },
7546 };
7547
7548 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7549         .num_items = 4,
7550         .items = {
7551                 { "Mic", 0x0 },
7552                 { "Internal Mic", 0x1 },
7553                 { "Line", 0x2 },
7554                 { "CD", 0x4 },
7555         },
7556 };
7557
7558 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7559         .num_items = 2,
7560         .items = {
7561                 { "Mic", 0x0 },
7562                 { "Internal Mic", 0x1 },
7563         },
7564 };
7565
7566 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7567         .num_items = 3,
7568         .items = {
7569                 { "Mic", 0x0 },
7570                 { "Front Mic", 0x1 },
7571                 { "Line", 0x4 },
7572         },
7573 };
7574
7575 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7576         .num_items = 2,
7577         .items = {
7578                 { "Mic", 0x0 },
7579                 { "Line", 0x2 },
7580         },
7581 };
7582
7583 static struct hda_input_mux alc889A_mb31_capture_source = {
7584         .num_items = 2,
7585         .items = {
7586                 { "Mic", 0x0 },
7587                 /* Front Mic (0x01) unused */
7588                 { "Line", 0x2 },
7589                 /* Line 2 (0x03) unused */
7590                 /* CD (0x04) unused? */
7591         },
7592 };
7593
7594 static struct hda_input_mux alc889A_imac91_capture_source = {
7595         .num_items = 2,
7596         .items = {
7597                 { "Mic", 0x01 },
7598                 { "Line", 0x2 }, /* Not sure! */
7599         },
7600 };
7601
7602 /*
7603  * 2ch mode
7604  */
7605 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7606         { 2, NULL }
7607 };
7608
7609 /*
7610  * 2ch mode
7611  */
7612 static struct hda_verb alc882_3ST_ch2_init[] = {
7613         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7614         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7615         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7616         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7617         { } /* end */
7618 };
7619
7620 /*
7621  * 4ch mode
7622  */
7623 static struct hda_verb alc882_3ST_ch4_init[] = {
7624         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7625         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7626         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7627         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7628         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7629         { } /* end */
7630 };
7631
7632 /*
7633  * 6ch mode
7634  */
7635 static struct hda_verb alc882_3ST_ch6_init[] = {
7636         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7637         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7638         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7639         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7640         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7641         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7642         { } /* end */
7643 };
7644
7645 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
7646         { 2, alc882_3ST_ch2_init },
7647         { 4, alc882_3ST_ch4_init },
7648         { 6, alc882_3ST_ch6_init },
7649 };
7650
7651 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
7652
7653 /*
7654  * 2ch mode
7655  */
7656 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
7657         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
7658         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7659         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7660         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7661         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7662         { } /* end */
7663 };
7664
7665 /*
7666  * 4ch mode
7667  */
7668 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
7669         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7670         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7671         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7672         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7673         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7674         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7675         { } /* end */
7676 };
7677
7678 /*
7679  * 6ch mode
7680  */
7681 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
7682         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7683         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7684         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7685         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7686         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7687         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7688         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7689         { } /* end */
7690 };
7691
7692 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
7693         { 2, alc883_3ST_ch2_clevo_init },
7694         { 4, alc883_3ST_ch4_clevo_init },
7695         { 6, alc883_3ST_ch6_clevo_init },
7696 };
7697
7698
7699 /*
7700  * 6ch mode
7701  */
7702 static struct hda_verb alc882_sixstack_ch6_init[] = {
7703         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7704         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7705         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7706         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7707         { } /* end */
7708 };
7709
7710 /*
7711  * 8ch mode
7712  */
7713 static struct hda_verb alc882_sixstack_ch8_init[] = {
7714         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7715         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7716         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7717         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7718         { } /* end */
7719 };
7720
7721 static struct hda_channel_mode alc882_sixstack_modes[2] = {
7722         { 6, alc882_sixstack_ch6_init },
7723         { 8, alc882_sixstack_ch8_init },
7724 };
7725
7726
7727 /* Macbook Air 2,1 */
7728
7729 static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7730       { 2, NULL },
7731 };
7732
7733 /*
7734  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7735  */
7736
7737 /*
7738  * 2ch mode
7739  */
7740 static struct hda_verb alc885_mbp_ch2_init[] = {
7741         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7742         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7743         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7744         { } /* end */
7745 };
7746
7747 /*
7748  * 4ch mode
7749  */
7750 static struct hda_verb alc885_mbp_ch4_init[] = {
7751         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7752         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7753         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7754         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7755         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7756         { } /* end */
7757 };
7758
7759 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7760         { 2, alc885_mbp_ch2_init },
7761         { 4, alc885_mbp_ch4_init },
7762 };
7763
7764 /*
7765  * 2ch
7766  * Speakers/Woofer/HP = Front
7767  * LineIn = Input
7768  */
7769 static struct hda_verb alc885_mb5_ch2_init[] = {
7770         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7771         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7772         { } /* end */
7773 };
7774
7775 /*
7776  * 6ch mode
7777  * Speakers/HP = Front
7778  * Woofer = LFE
7779  * LineIn = Surround
7780  */
7781 static struct hda_verb alc885_mb5_ch6_init[] = {
7782         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7783         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7784         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7785         { } /* end */
7786 };
7787
7788 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
7789         { 2, alc885_mb5_ch2_init },
7790         { 6, alc885_mb5_ch6_init },
7791 };
7792
7793 #define alc885_macmini3_6ch_modes       alc885_mb5_6ch_modes
7794
7795 /*
7796  * 2ch mode
7797  */
7798 static struct hda_verb alc883_4ST_ch2_init[] = {
7799         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7800         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7801         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7802         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7803         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7804         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7805         { } /* end */
7806 };
7807
7808 /*
7809  * 4ch mode
7810  */
7811 static struct hda_verb alc883_4ST_ch4_init[] = {
7812         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7813         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7814         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7815         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7816         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7817         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7818         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7819         { } /* end */
7820 };
7821
7822 /*
7823  * 6ch mode
7824  */
7825 static struct hda_verb alc883_4ST_ch6_init[] = {
7826         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7827         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7828         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7829         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7830         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7831         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7832         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7833         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7834         { } /* end */
7835 };
7836
7837 /*
7838  * 8ch mode
7839  */
7840 static struct hda_verb alc883_4ST_ch8_init[] = {
7841         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7842         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7843         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7844         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7845         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7846         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7847         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7848         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7849         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7850         { } /* end */
7851 };
7852
7853 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
7854         { 2, alc883_4ST_ch2_init },
7855         { 4, alc883_4ST_ch4_init },
7856         { 6, alc883_4ST_ch6_init },
7857         { 8, alc883_4ST_ch8_init },
7858 };
7859
7860
7861 /*
7862  * 2ch mode
7863  */
7864 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7865         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7866         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7867         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7868         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7869         { } /* end */
7870 };
7871
7872 /*
7873  * 4ch mode
7874  */
7875 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7876         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7877         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7878         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7879         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7880         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7881         { } /* end */
7882 };
7883
7884 /*
7885  * 6ch mode
7886  */
7887 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7888         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7889         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7890         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7891         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7892         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7893         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7894         { } /* end */
7895 };
7896
7897 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7898         { 2, alc883_3ST_ch2_intel_init },
7899         { 4, alc883_3ST_ch4_intel_init },
7900         { 6, alc883_3ST_ch6_intel_init },
7901 };
7902
7903 /*
7904  * 2ch mode
7905  */
7906 static struct hda_verb alc889_ch2_intel_init[] = {
7907         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7908         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7909         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7910         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7911         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7912         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7913         { } /* end */
7914 };
7915
7916 /*
7917  * 6ch mode
7918  */
7919 static struct hda_verb alc889_ch6_intel_init[] = {
7920         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7921         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7922         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7923         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7924         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7925         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7926         { } /* end */
7927 };
7928
7929 /*
7930  * 8ch mode
7931  */
7932 static struct hda_verb alc889_ch8_intel_init[] = {
7933         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7934         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7935         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7936         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7937         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7938         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7939         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7940         { } /* end */
7941 };
7942
7943 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7944         { 2, alc889_ch2_intel_init },
7945         { 6, alc889_ch6_intel_init },
7946         { 8, alc889_ch8_intel_init },
7947 };
7948
7949 /*
7950  * 6ch mode
7951  */
7952 static struct hda_verb alc883_sixstack_ch6_init[] = {
7953         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7954         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7955         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7956         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7957         { } /* end */
7958 };
7959
7960 /*
7961  * 8ch mode
7962  */
7963 static struct hda_verb alc883_sixstack_ch8_init[] = {
7964         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7965         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7966         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7967         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7968         { } /* end */
7969 };
7970
7971 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7972         { 6, alc883_sixstack_ch6_init },
7973         { 8, alc883_sixstack_ch8_init },
7974 };
7975
7976
7977 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7978  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7979  */
7980 static struct snd_kcontrol_new alc882_base_mixer[] = {
7981         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7982         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7983         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7984         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7985         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7986         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7987         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7988         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7989         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7990         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7991         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7992         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7993         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7994         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7995         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7996         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7997         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
7998         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7999         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8000         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8001         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8002         { } /* end */
8003 };
8004
8005 /* Macbook Air 2,1 same control for HP and internal Speaker */
8006
8007 static struct snd_kcontrol_new alc885_mba21_mixer[] = {
8008       HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8009       HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
8010      { }
8011 };
8012
8013
8014 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
8015         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8016         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
8017         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8018         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
8019         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8020         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8021         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8022         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8023         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8024         HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT),
8025         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT),
8026         { } /* end */
8027 };
8028
8029 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
8030         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8031         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8032         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8033         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8034         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8035         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
8036         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
8037         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
8038         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
8039         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
8040         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8041         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8042         HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT),
8043         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0x00, HDA_INPUT),
8044         { } /* end */
8045 };
8046
8047 static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
8048         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8049         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8050         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8051         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8052         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8053         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
8054         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
8055         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
8056         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
8057         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
8058         HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT),
8059         { } /* end */
8060 };
8061
8062 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
8063         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8064         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
8065         { } /* end */
8066 };
8067
8068
8069 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
8070         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8071         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8072         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8073         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8074         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8075         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8076         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8077         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8078         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8079         { } /* end */
8080 };
8081
8082 static struct snd_kcontrol_new alc882_targa_mixer[] = {
8083         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8084         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8085         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8086         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8087         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8088         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8089         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8090         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8091         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8092         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8093         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8094         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8095         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8096         { } /* end */
8097 };
8098
8099 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
8100  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
8101  */
8102 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
8103         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8104         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8105         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8106         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
8107         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8108         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8109         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8110         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8111         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
8112         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
8113         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8114         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8115         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8116         { } /* end */
8117 };
8118
8119 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
8120         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8121         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8122         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8123         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8124         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8125         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8126         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8127         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8128         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8129         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8130         { } /* end */
8131 };
8132
8133 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
8134         {
8135                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8136                 .name = "Channel Mode",
8137                 .info = alc_ch_mode_info,
8138                 .get = alc_ch_mode_get,
8139                 .put = alc_ch_mode_put,
8140         },
8141         { } /* end */
8142 };
8143
8144 static struct hda_verb alc882_base_init_verbs[] = {
8145         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8146         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8147         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8148         /* Rear mixer */
8149         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8150         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8151         /* CLFE mixer */
8152         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8153         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8154         /* Side mixer */
8155         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8156         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8157
8158         /* Front Pin: output 0 (0x0c) */
8159         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8160         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8161         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8162         /* Rear Pin: output 1 (0x0d) */
8163         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8164         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8165         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8166         /* CLFE Pin: output 2 (0x0e) */
8167         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8168         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8169         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8170         /* Side Pin: output 3 (0x0f) */
8171         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8172         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8173         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8174         /* Mic (rear) pin: input vref at 80% */
8175         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8176         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8177         /* Front Mic pin: input vref at 80% */
8178         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8179         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8180         /* Line In pin: input */
8181         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8182         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8183         /* Line-2 In: Headphone output (output 0 - 0x0c) */
8184         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8185         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8186         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8187         /* CD pin widget for input */
8188         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8189
8190         /* FIXME: use matrix-type input source selection */
8191         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8192         /* Input mixer2 */
8193         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8194         /* Input mixer3 */
8195         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8196         /* ADC2: mute amp left and right */
8197         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8198         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8199         /* ADC3: mute amp left and right */
8200         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8201         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8202
8203         { }
8204 };
8205
8206 static struct hda_verb alc882_adc1_init_verbs[] = {
8207         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8208         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8209         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8210         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8211         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8212         /* ADC1: mute amp left and right */
8213         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8214         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8215         { }
8216 };
8217
8218 static struct hda_verb alc882_eapd_verbs[] = {
8219         /* change to EAPD mode */
8220         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8221         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
8222         { }
8223 };
8224
8225 static struct hda_verb alc889_eapd_verbs[] = {
8226         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
8227         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
8228         { }
8229 };
8230
8231 static struct hda_verb alc_hp15_unsol_verbs[] = {
8232         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8233         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8234         {}
8235 };
8236
8237 static struct hda_verb alc885_init_verbs[] = {
8238         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8239         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8240         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8241         /* Rear mixer */
8242         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8243         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8244         /* CLFE mixer */
8245         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8246         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8247         /* Side mixer */
8248         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8249         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8250
8251         /* Front HP Pin: output 0 (0x0c) */
8252         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8253         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8254         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8255         /* Front Pin: output 0 (0x0c) */
8256         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8257         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8258         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8259         /* Rear Pin: output 1 (0x0d) */
8260         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8261         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8262         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
8263         /* CLFE Pin: output 2 (0x0e) */
8264         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8265         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8266         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8267         /* Side Pin: output 3 (0x0f) */
8268         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8269         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8270         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8271         /* Mic (rear) pin: input vref at 80% */
8272         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8273         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8274         /* Front Mic pin: input vref at 80% */
8275         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8276         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8277         /* Line In pin: input */
8278         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8279         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8280
8281         /* Mixer elements: 0x18, , 0x1a, 0x1b */
8282         /* Input mixer1 */
8283         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8284         /* Input mixer2 */
8285         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8286         /* Input mixer3 */
8287         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8288         /* ADC2: mute amp left and right */
8289         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8290         /* ADC3: mute amp left and right */
8291         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8292
8293         { }
8294 };
8295
8296 static struct hda_verb alc885_init_input_verbs[] = {
8297         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8298         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8299         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
8300         { }
8301 };
8302
8303
8304 /* Unmute Selector 24h and set the default input to front mic */
8305 static struct hda_verb alc889_init_input_verbs[] = {
8306         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
8307         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8308         { }
8309 };
8310
8311
8312 #define alc883_init_verbs       alc882_base_init_verbs
8313
8314 /* Mac Pro test */
8315 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
8316         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8317         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8318         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
8319         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8320         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8321         /* FIXME: this looks suspicious...
8322         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
8323         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
8324         */
8325         { } /* end */
8326 };
8327
8328 static struct hda_verb alc882_macpro_init_verbs[] = {
8329         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8330         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8331         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8332         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8333         /* Front Pin: output 0 (0x0c) */
8334         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8335         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8336         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8337         /* Front Mic pin: input vref at 80% */
8338         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8339         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8340         /* Speaker:  output */
8341         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8342         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8343         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
8344         /* Headphone output (output 0 - 0x0c) */
8345         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8346         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8347         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8348
8349         /* FIXME: use matrix-type input source selection */
8350         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8351         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8352         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8353         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8354         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8355         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8356         /* Input mixer2 */
8357         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8358         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8359         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8360         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8361         /* Input mixer3 */
8362         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8363         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8364         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8365         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8366         /* ADC1: mute amp left and right */
8367         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8368         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8369         /* ADC2: mute amp left and right */
8370         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8371         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8372         /* ADC3: mute amp left and right */
8373         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8374         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8375
8376         { }
8377 };
8378
8379 /* Macbook 5,1 */
8380 static struct hda_verb alc885_mb5_init_verbs[] = {
8381         /* DACs */
8382         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8383         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8384         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8385         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8386         /* Front mixer */
8387         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8388         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8389         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8390         /* Surround mixer */
8391         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8392         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8393         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8394         /* LFE mixer */
8395         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8396         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8397         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8398         /* HP mixer */
8399         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8400         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8401         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8402         /* Front Pin (0x0c) */
8403         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8404         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8405         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8406         /* LFE Pin (0x0e) */
8407         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8408         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8409         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8410         /* HP Pin (0x0f) */
8411         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8412         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8413         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8414         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8415         /* Front Mic pin: input vref at 80% */
8416         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8417         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8418         /* Line In pin */
8419         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8420         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8421
8422         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)},
8423         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)},
8424         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)},
8425         { }
8426 };
8427
8428 /* Macmini 3,1 */
8429 static struct hda_verb alc885_macmini3_init_verbs[] = {
8430         /* DACs */
8431         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8432         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8433         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8434         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8435         /* Front mixer */
8436         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8437         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8438         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8439         /* Surround mixer */
8440         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8441         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8442         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8443         /* LFE mixer */
8444         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8445         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8446         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8447         /* HP mixer */
8448         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8449         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8450         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8451         /* Front Pin (0x0c) */
8452         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8453         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8454         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8455         /* LFE Pin (0x0e) */
8456         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8457         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8458         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8459         /* HP Pin (0x0f) */
8460         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8461         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8462         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8463         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8464         /* Line In pin */
8465         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8466         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8467
8468         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8469         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8470         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8471         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8472         { }
8473 };
8474
8475
8476 static struct hda_verb alc885_mba21_init_verbs[] = {
8477         /*Internal and HP Speaker Mixer*/
8478         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8479         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8480         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8481         /*Internal Speaker Pin (0x0c)*/
8482         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8483         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8484         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8485         /* HP Pin: output 0 (0x0e) */
8486         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8487         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8488         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8489         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8490         /* Line in (is hp when jack connected)*/
8491         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8492         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8493
8494         { }
8495  };
8496
8497
8498 /* Macbook Pro rev3 */
8499 static struct hda_verb alc885_mbp3_init_verbs[] = {
8500         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8501         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8502         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8503         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8504         /* Rear mixer */
8505         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8506         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8507         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8508         /* HP mixer */
8509         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8510         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8511         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8512         /* Front Pin: output 0 (0x0c) */
8513         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8514         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8515         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8516         /* HP Pin: output 0 (0x0e) */
8517         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8518         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8519         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
8520         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8521         /* Mic (rear) pin: input vref at 80% */
8522         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8523         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8524         /* Front Mic pin: input vref at 80% */
8525         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8526         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8527         /* Line In pin: use output 1 when in LineOut mode */
8528         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8529         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8530         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8531
8532         /* FIXME: use matrix-type input source selection */
8533         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8534         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8535         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8536         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8537         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8538         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8539         /* Input mixer2 */
8540         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8541         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8542         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8543         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8544         /* Input mixer3 */
8545         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8546         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8547         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8548         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8549         /* ADC1: mute amp left and right */
8550         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8551         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8552         /* ADC2: mute amp left and right */
8553         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8554         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8555         /* ADC3: mute amp left and right */
8556         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8557         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8558
8559         { }
8560 };
8561
8562 /* iMac 9,1 */
8563 static struct hda_verb alc885_imac91_init_verbs[] = {
8564         /* Internal Speaker Pin (0x0c) */
8565         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8566         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8567         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8568         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8569         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8570         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8571         /* HP Pin: Rear */
8572         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8573         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8574         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8575         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8576         /* Line in Rear */
8577         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8578         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8579         /* Front Mic pin: input vref at 80% */
8580         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8581         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8582         /* Rear mixer */
8583         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8584         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8585         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8586         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
8587         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8588         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8589         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8590         /* 0x24 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8591         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8592         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8593         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8594         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8595         /* 0x23 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8596         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8597         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8598         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8599         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8600         /* 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8601         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8602         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8603         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8604         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8605         /* 0x07 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8606         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8607         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8608         /* 0x08 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8609         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8610         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8611         /* 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8612         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8613         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8614         { }
8615 };
8616
8617 /* iMac 24 mixer. */
8618 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
8619         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8620         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
8621         { } /* end */
8622 };
8623
8624 /* iMac 24 init verbs. */
8625 static struct hda_verb alc885_imac24_init_verbs[] = {
8626         /* Internal speakers: output 0 (0x0c) */
8627         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8628         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8629         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8630         /* Internal speakers: output 0 (0x0c) */
8631         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8632         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8633         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8634         /* Headphone: output 0 (0x0c) */
8635         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8636         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8637         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8638         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8639         /* Front Mic: input vref at 80% */
8640         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8641         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8642         { }
8643 };
8644
8645 /* Toggle speaker-output according to the hp-jack state */
8646 static void alc885_imac24_setup(struct hda_codec *codec)
8647 {
8648         struct alc_spec *spec = codec->spec;
8649
8650         spec->autocfg.hp_pins[0] = 0x14;
8651         spec->autocfg.speaker_pins[0] = 0x18;
8652         spec->autocfg.speaker_pins[1] = 0x1a;
8653 }
8654
8655 #define alc885_mb5_setup        alc885_imac24_setup
8656 #define alc885_macmini3_setup   alc885_imac24_setup
8657
8658 /* Macbook Air 2,1 */
8659 static void alc885_mba21_setup(struct hda_codec *codec)
8660 {
8661        struct alc_spec *spec = codec->spec;
8662
8663        spec->autocfg.hp_pins[0] = 0x14;
8664        spec->autocfg.speaker_pins[0] = 0x18;
8665 }
8666
8667
8668
8669 static void alc885_mbp3_setup(struct hda_codec *codec)
8670 {
8671         struct alc_spec *spec = codec->spec;
8672
8673         spec->autocfg.hp_pins[0] = 0x15;
8674         spec->autocfg.speaker_pins[0] = 0x14;
8675 }
8676
8677 static void alc885_imac91_setup(struct hda_codec *codec)
8678 {
8679         struct alc_spec *spec = codec->spec;
8680
8681         spec->autocfg.hp_pins[0] = 0x14;
8682         spec->autocfg.speaker_pins[0] = 0x18;
8683         spec->autocfg.speaker_pins[1] = 0x1a;
8684 }
8685
8686 static struct hda_verb alc882_targa_verbs[] = {
8687         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8688         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8689
8690         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8691         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8692
8693         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8694         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8695         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8696
8697         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8698         { } /* end */
8699 };
8700
8701 /* toggle speaker-output according to the hp-jack state */
8702 static void alc882_targa_automute(struct hda_codec *codec)
8703 {
8704         struct alc_spec *spec = codec->spec;
8705         alc_automute_amp(codec);
8706         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8707                                   spec->jack_present ? 1 : 3);
8708 }
8709
8710 static void alc882_targa_setup(struct hda_codec *codec)
8711 {
8712         struct alc_spec *spec = codec->spec;
8713
8714         spec->autocfg.hp_pins[0] = 0x14;
8715         spec->autocfg.speaker_pins[0] = 0x1b;
8716 }
8717
8718 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8719 {
8720         if ((res >> 26) == ALC880_HP_EVENT)
8721                 alc882_targa_automute(codec);
8722 }
8723
8724 static struct hda_verb alc882_asus_a7j_verbs[] = {
8725         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8726         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8727
8728         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8729         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8730         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8731
8732         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8733         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8734         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8735
8736         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8737         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8738         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8739         { } /* end */
8740 };
8741
8742 static struct hda_verb alc882_asus_a7m_verbs[] = {
8743         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8744         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8745
8746         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8747         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8748         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8749
8750         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8751         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8752         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8753
8754         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8755         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8756         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8757         { } /* end */
8758 };
8759
8760 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8761 {
8762         unsigned int gpiostate, gpiomask, gpiodir;
8763
8764         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8765                                        AC_VERB_GET_GPIO_DATA, 0);
8766
8767         if (!muted)
8768                 gpiostate |= (1 << pin);
8769         else
8770                 gpiostate &= ~(1 << pin);
8771
8772         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
8773                                       AC_VERB_GET_GPIO_MASK, 0);
8774         gpiomask |= (1 << pin);
8775
8776         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
8777                                      AC_VERB_GET_GPIO_DIRECTION, 0);
8778         gpiodir |= (1 << pin);
8779
8780
8781         snd_hda_codec_write(codec, codec->afg, 0,
8782                             AC_VERB_SET_GPIO_MASK, gpiomask);
8783         snd_hda_codec_write(codec, codec->afg, 0,
8784                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
8785
8786         msleep(1);
8787
8788         snd_hda_codec_write(codec, codec->afg, 0,
8789                             AC_VERB_SET_GPIO_DATA, gpiostate);
8790 }
8791
8792 /* set up GPIO at initialization */
8793 static void alc885_macpro_init_hook(struct hda_codec *codec)
8794 {
8795         alc882_gpio_mute(codec, 0, 0);
8796         alc882_gpio_mute(codec, 1, 0);
8797 }
8798
8799 /* set up GPIO and update auto-muting at initialization */
8800 static void alc885_imac24_init_hook(struct hda_codec *codec)
8801 {
8802         alc885_macpro_init_hook(codec);
8803         alc_automute_amp(codec);
8804 }
8805
8806 /*
8807  * generic initialization of ADC, input mixers and output mixers
8808  */
8809 static struct hda_verb alc883_auto_init_verbs[] = {
8810         /*
8811          * Unmute ADC0-2 and set the default input to mic-in
8812          */
8813         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8814         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8815         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8816         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8817
8818         /*
8819          * Set up output mixers (0x0c - 0x0f)
8820          */
8821         /* set vol=0 to output mixers */
8822         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8823         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8824         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8825         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8826         /* set up input amps for analog loopback */
8827         /* Amp Indices: DAC = 0, mixer = 1 */
8828         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8829         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8830         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8831         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8832         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8833         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8834         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8835         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8836         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8837         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8838
8839         /* FIXME: use matrix-type input source selection */
8840         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8841         /* Input mixer2 */
8842         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8843         /* Input mixer3 */
8844         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8845         { }
8846 };
8847
8848 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
8849 static struct hda_verb alc889A_mb31_ch2_init[] = {
8850         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8851         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8852         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8853         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8854         { } /* end */
8855 };
8856
8857 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
8858 static struct hda_verb alc889A_mb31_ch4_init[] = {
8859         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8860         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8861         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8862         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8863         { } /* end */
8864 };
8865
8866 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
8867 static struct hda_verb alc889A_mb31_ch5_init[] = {
8868         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
8869         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8870         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8871         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8872         { } /* end */
8873 };
8874
8875 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
8876 static struct hda_verb alc889A_mb31_ch6_init[] = {
8877         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
8878         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
8879         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8880         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8881         { } /* end */
8882 };
8883
8884 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
8885         { 2, alc889A_mb31_ch2_init },
8886         { 4, alc889A_mb31_ch4_init },
8887         { 5, alc889A_mb31_ch5_init },
8888         { 6, alc889A_mb31_ch6_init },
8889 };
8890
8891 static struct hda_verb alc883_medion_eapd_verbs[] = {
8892         /* eanable EAPD on medion laptop */
8893         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8894         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8895         { }
8896 };
8897
8898 #define alc883_base_mixer       alc882_base_mixer
8899
8900 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8901         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8902         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8903         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8904         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8905         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8906         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8907         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8908         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8909         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8910         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8911         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8912         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8913         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8914         { } /* end */
8915 };
8916
8917 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8918         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8919         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8920         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8921         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8922         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8923         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8924         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8925         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8926         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
8927         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8928         { } /* end */
8929 };
8930
8931 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8932         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8933         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8934         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8935         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8936         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8937         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8938         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8939         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8940         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
8941         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8942         { } /* end */
8943 };
8944
8945 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8946         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8947         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8948         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8949         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8950         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8951         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8952         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8953         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8954         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8955         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8956         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8957         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8958         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8959         { } /* end */
8960 };
8961
8962 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8963         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8964         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8965         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8966         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8967         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8968         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8969         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8970         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8971         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8972         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8973         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8974         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8975         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8976         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8977         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8978         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8979         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8980         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8981         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8982         { } /* end */
8983 };
8984
8985 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8986         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8987         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8988         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8989         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8990         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8991                               HDA_OUTPUT),
8992         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8993         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8994         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8995         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8996         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8997         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8998         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8999         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9000         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9001         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
9002         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9003         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9004         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT),
9005         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9006         { } /* end */
9007 };
9008
9009 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
9010         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9011         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9012         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9013         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9014         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
9015                               HDA_OUTPUT),
9016         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9017         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9018         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9019         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9020         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
9021         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9022         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9023         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9024         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
9025         HDA_CODEC_VOLUME("Mic Boost Volume", 0x1b, 0, HDA_INPUT),
9026         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
9027         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9028         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT),
9029         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9030         { } /* end */
9031 };
9032
9033 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
9034         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9035         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9036         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9037         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9038         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9039         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9040         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9041         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9042         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9043         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9044         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9045         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9046         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9047         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9048         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9049         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9050         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9051         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9052         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9053         { } /* end */
9054 };
9055
9056 static struct snd_kcontrol_new alc883_targa_mixer[] = {
9057         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9058         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9059         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9060         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9061         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9062         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9063         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9064         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9065         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9066         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9067         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9068         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9069         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9070         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9071         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9072         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9073         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9074         { } /* end */
9075 };
9076
9077 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
9078         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9079         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9080         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9081         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9082         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9083         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9084         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9085         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9086         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9087         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9088         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9089         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9090         { } /* end */
9091 };
9092
9093 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
9094         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9095         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9096         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9097         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9098         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9099         { } /* end */
9100 };
9101
9102 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
9103         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9104         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9105         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9106         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9107         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9108         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9109         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9110         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9111         { } /* end */
9112 };
9113
9114 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
9115         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9116         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
9117         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9118         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9119         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9120         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9121         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9122         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9123         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9124         { } /* end */
9125 };
9126
9127 static struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
9128         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9129         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9130         HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9131         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
9132         HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
9133         HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
9134         { } /* end */
9135 };
9136
9137 static struct hda_verb alc883_medion_wim2160_verbs[] = {
9138         /* Unmute front mixer */
9139         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9140         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9141
9142         /* Set speaker pin to front mixer */
9143         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9144
9145         /* Init headphone pin */
9146         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9147         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9148         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9149         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9150
9151         { } /* end */
9152 };
9153
9154 /* toggle speaker-output according to the hp-jack state */
9155 static void alc883_medion_wim2160_setup(struct hda_codec *codec)
9156 {
9157         struct alc_spec *spec = codec->spec;
9158
9159         spec->autocfg.hp_pins[0] = 0x1a;
9160         spec->autocfg.speaker_pins[0] = 0x15;
9161 }
9162
9163 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
9164         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9165         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9166         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9167         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9168         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, 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         { } /* end */
9173 };
9174
9175 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
9176         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9177         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9178         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9179         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9180         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9181         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9182         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9183         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9184         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9185         { } /* end */
9186 };
9187
9188 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
9189         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9190         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9191         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9192         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
9193         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
9194                                                 0x0d, 1, 0x0, HDA_OUTPUT),
9195         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
9196         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
9197         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
9198         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9199         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9200         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9201         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9202         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9203         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9204         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9205         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9206         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9207         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9208         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9209         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9210         { } /* end */
9211 };
9212
9213 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
9214         /* Output mixers */
9215         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
9216         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
9217         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
9218         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
9219         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
9220                 HDA_OUTPUT),
9221         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
9222         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
9223         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
9224         /* Output switches */
9225         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
9226         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
9227         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
9228         /* Boost mixers */
9229         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT),
9230         HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT),
9231         /* Input mixers */
9232         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
9233         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
9234         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9235         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9236         { } /* end */
9237 };
9238
9239 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
9240         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9241         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9242         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9243         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9244         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
9245         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9246         { } /* end */
9247 };
9248
9249 static struct hda_bind_ctls alc883_bind_cap_vol = {
9250         .ops = &snd_hda_bind_vol,
9251         .values = {
9252                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9253                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9254                 0
9255         },
9256 };
9257
9258 static struct hda_bind_ctls alc883_bind_cap_switch = {
9259         .ops = &snd_hda_bind_sw,
9260         .values = {
9261                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9262                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9263                 0
9264         },
9265 };
9266
9267 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
9268         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9269         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9270         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9271         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9272         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9273         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9274         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9275         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9276         { } /* end */
9277 };
9278
9279 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
9280         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
9281         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
9282         {
9283                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9284                 /* .name = "Capture Source", */
9285                 .name = "Input Source",
9286                 .count = 1,
9287                 .info = alc_mux_enum_info,
9288                 .get = alc_mux_enum_get,
9289                 .put = alc_mux_enum_put,
9290         },
9291         { } /* end */
9292 };
9293
9294 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
9295         {
9296                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9297                 .name = "Channel Mode",
9298                 .info = alc_ch_mode_info,
9299                 .get = alc_ch_mode_get,
9300                 .put = alc_ch_mode_put,
9301         },
9302         { } /* end */
9303 };
9304
9305 /* toggle speaker-output according to the hp-jack state */
9306 static void alc883_mitac_setup(struct hda_codec *codec)
9307 {
9308         struct alc_spec *spec = codec->spec;
9309
9310         spec->autocfg.hp_pins[0] = 0x15;
9311         spec->autocfg.speaker_pins[0] = 0x14;
9312         spec->autocfg.speaker_pins[1] = 0x17;
9313 }
9314
9315 static struct hda_verb alc883_mitac_verbs[] = {
9316         /* HP */
9317         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9318         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9319         /* Subwoofer */
9320         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9321         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9322
9323         /* enable unsolicited event */
9324         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9325         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
9326
9327         { } /* end */
9328 };
9329
9330 static struct hda_verb alc883_clevo_m540r_verbs[] = {
9331         /* HP */
9332         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9333         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9334         /* Int speaker */
9335         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
9336
9337         /* enable unsolicited event */
9338         /*
9339         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9340         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9341         */
9342
9343         { } /* end */
9344 };
9345
9346 static struct hda_verb alc883_clevo_m720_verbs[] = {
9347         /* HP */
9348         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9349         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9350         /* Int speaker */
9351         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
9352         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9353
9354         /* enable unsolicited event */
9355         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9356         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9357
9358         { } /* end */
9359 };
9360
9361 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
9362         /* HP */
9363         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9364         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9365         /* Subwoofer */
9366         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9367         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9368
9369         /* enable unsolicited event */
9370         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9371
9372         { } /* end */
9373 };
9374
9375 static struct hda_verb alc883_targa_verbs[] = {
9376         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9377         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9378
9379         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9380         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9381
9382 /* Connect Line-Out side jack (SPDIF) to Side */
9383         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9384         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9385         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
9386 /* Connect Mic jack to CLFE */
9387         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9388         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9389         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
9390 /* Connect Line-in jack to Surround */
9391         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9392         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9393         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
9394 /* Connect HP out jack to Front */
9395         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9396         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9397         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9398
9399         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9400
9401         { } /* end */
9402 };
9403
9404 static struct hda_verb alc883_lenovo_101e_verbs[] = {
9405         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9406         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
9407         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
9408         { } /* end */
9409 };
9410
9411 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
9412         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9413         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9414         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9415         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9416         { } /* end */
9417 };
9418
9419 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
9420         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9421         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9422         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9423         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
9424         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
9425         { } /* end */
9426 };
9427
9428 static struct hda_verb alc883_haier_w66_verbs[] = {
9429         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9430         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9431
9432         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9433
9434         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9435         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9436         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9437         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9438         { } /* end */
9439 };
9440
9441 static struct hda_verb alc888_lenovo_sky_verbs[] = {
9442         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9443         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9444         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9445         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9446         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9447         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9448         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9449         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9450         { } /* end */
9451 };
9452
9453 static struct hda_verb alc888_6st_dell_verbs[] = {
9454         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9455         { }
9456 };
9457
9458 static struct hda_verb alc883_vaiott_verbs[] = {
9459         /* HP */
9460         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9461         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9462
9463         /* enable unsolicited event */
9464         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9465
9466         { } /* end */
9467 };
9468
9469 static void alc888_3st_hp_setup(struct hda_codec *codec)
9470 {
9471         struct alc_spec *spec = codec->spec;
9472
9473         spec->autocfg.hp_pins[0] = 0x1b;
9474         spec->autocfg.speaker_pins[0] = 0x14;
9475         spec->autocfg.speaker_pins[1] = 0x16;
9476         spec->autocfg.speaker_pins[2] = 0x18;
9477 }
9478
9479 static struct hda_verb alc888_3st_hp_verbs[] = {
9480         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
9481         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
9482         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
9483         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9484         { } /* end */
9485 };
9486
9487 /*
9488  * 2ch mode
9489  */
9490 static struct hda_verb alc888_3st_hp_2ch_init[] = {
9491         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9492         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9493         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
9494         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9495         { } /* end */
9496 };
9497
9498 /*
9499  * 4ch mode
9500  */
9501 static struct hda_verb alc888_3st_hp_4ch_init[] = {
9502         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9503         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9504         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9505         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9506         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9507         { } /* end */
9508 };
9509
9510 /*
9511  * 6ch mode
9512  */
9513 static struct hda_verb alc888_3st_hp_6ch_init[] = {
9514         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9515         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9516         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
9517         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9518         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9519         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9520         { } /* end */
9521 };
9522
9523 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
9524         { 2, alc888_3st_hp_2ch_init },
9525         { 4, alc888_3st_hp_4ch_init },
9526         { 6, alc888_3st_hp_6ch_init },
9527 };
9528
9529 /* toggle front-jack and RCA according to the hp-jack state */
9530 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
9531 {
9532         unsigned int present = snd_hda_jack_detect(codec, 0x1b);
9533
9534         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9535                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9536         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9537                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9538 }
9539
9540 /* toggle RCA according to the front-jack state */
9541 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
9542 {
9543         unsigned int present = snd_hda_jack_detect(codec, 0x14);
9544
9545         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9546                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9547 }
9548
9549 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
9550                                              unsigned int res)
9551 {
9552         if ((res >> 26) == ALC880_HP_EVENT)
9553                 alc888_lenovo_ms7195_front_automute(codec);
9554         if ((res >> 26) == ALC880_FRONT_EVENT)
9555                 alc888_lenovo_ms7195_rca_automute(codec);
9556 }
9557
9558 /* toggle speaker-output according to the hp-jack state */
9559 static void alc883_lenovo_nb0763_setup(struct hda_codec *codec)
9560 {
9561         struct alc_spec *spec = codec->spec;
9562
9563         spec->autocfg.hp_pins[0] = 0x14;
9564         spec->autocfg.speaker_pins[0] = 0x15;
9565 }
9566
9567 /* toggle speaker-output according to the hp-jack state */
9568 #define alc883_targa_init_hook          alc882_targa_init_hook
9569 #define alc883_targa_unsol_event        alc882_targa_unsol_event
9570
9571 static void alc883_clevo_m720_setup(struct hda_codec *codec)
9572 {
9573         struct alc_spec *spec = codec->spec;
9574
9575         spec->autocfg.hp_pins[0] = 0x15;
9576         spec->autocfg.speaker_pins[0] = 0x14;
9577 }
9578
9579 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
9580 {
9581         alc_automute_amp(codec);
9582         alc88x_simple_mic_automute(codec);
9583 }
9584
9585 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
9586                                            unsigned int res)
9587 {
9588         switch (res >> 26) {
9589         case ALC880_MIC_EVENT:
9590                 alc88x_simple_mic_automute(codec);
9591                 break;
9592         default:
9593                 alc_automute_amp_unsol_event(codec, res);
9594                 break;
9595         }
9596 }
9597
9598 /* toggle speaker-output according to the hp-jack state */
9599 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
9600 {
9601         struct alc_spec *spec = codec->spec;
9602
9603         spec->autocfg.hp_pins[0] = 0x14;
9604         spec->autocfg.speaker_pins[0] = 0x15;
9605 }
9606
9607 static void alc883_haier_w66_setup(struct hda_codec *codec)
9608 {
9609         struct alc_spec *spec = codec->spec;
9610
9611         spec->autocfg.hp_pins[0] = 0x1b;
9612         spec->autocfg.speaker_pins[0] = 0x14;
9613 }
9614
9615 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
9616 {
9617         int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
9618
9619         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9620                                  HDA_AMP_MUTE, bits);
9621 }
9622
9623 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
9624 {
9625         int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
9626
9627         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9628                                  HDA_AMP_MUTE, bits);
9629         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9630                                  HDA_AMP_MUTE, bits);
9631 }
9632
9633 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
9634                                            unsigned int res)
9635 {
9636         if ((res >> 26) == ALC880_HP_EVENT)
9637                 alc883_lenovo_101e_all_automute(codec);
9638         if ((res >> 26) == ALC880_FRONT_EVENT)
9639                 alc883_lenovo_101e_ispeaker_automute(codec);
9640 }
9641
9642 /* toggle speaker-output according to the hp-jack state */
9643 static void alc883_acer_aspire_setup(struct hda_codec *codec)
9644 {
9645         struct alc_spec *spec = codec->spec;
9646
9647         spec->autocfg.hp_pins[0] = 0x14;
9648         spec->autocfg.speaker_pins[0] = 0x15;
9649         spec->autocfg.speaker_pins[1] = 0x16;
9650 }
9651
9652 static struct hda_verb alc883_acer_eapd_verbs[] = {
9653         /* HP Pin: output 0 (0x0c) */
9654         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9655         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9656         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9657         /* Front Pin: output 0 (0x0c) */
9658         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9659         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9660         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9661         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
9662         /* eanable EAPD on medion laptop */
9663         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9664         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9665         /* enable unsolicited event */
9666         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9667         { }
9668 };
9669
9670 static void alc888_6st_dell_setup(struct hda_codec *codec)
9671 {
9672         struct alc_spec *spec = codec->spec;
9673
9674         spec->autocfg.hp_pins[0] = 0x1b;
9675         spec->autocfg.speaker_pins[0] = 0x14;
9676         spec->autocfg.speaker_pins[1] = 0x15;
9677         spec->autocfg.speaker_pins[2] = 0x16;
9678         spec->autocfg.speaker_pins[3] = 0x17;
9679 }
9680
9681 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9682 {
9683         struct alc_spec *spec = codec->spec;
9684
9685         spec->autocfg.hp_pins[0] = 0x1b;
9686         spec->autocfg.speaker_pins[0] = 0x14;
9687         spec->autocfg.speaker_pins[1] = 0x15;
9688         spec->autocfg.speaker_pins[2] = 0x16;
9689         spec->autocfg.speaker_pins[3] = 0x17;
9690         spec->autocfg.speaker_pins[4] = 0x1a;
9691 }
9692
9693 static void alc883_vaiott_setup(struct hda_codec *codec)
9694 {
9695         struct alc_spec *spec = codec->spec;
9696
9697         spec->autocfg.hp_pins[0] = 0x15;
9698         spec->autocfg.speaker_pins[0] = 0x14;
9699         spec->autocfg.speaker_pins[1] = 0x17;
9700 }
9701
9702 static struct hda_verb alc888_asus_m90v_verbs[] = {
9703         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9704         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9705         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9706         /* enable unsolicited event */
9707         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9708         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9709         { } /* end */
9710 };
9711
9712 static void alc883_mode2_setup(struct hda_codec *codec)
9713 {
9714         struct alc_spec *spec = codec->spec;
9715
9716         spec->autocfg.hp_pins[0] = 0x1b;
9717         spec->autocfg.speaker_pins[0] = 0x14;
9718         spec->autocfg.speaker_pins[1] = 0x15;
9719         spec->autocfg.speaker_pins[2] = 0x16;
9720         spec->ext_mic.pin = 0x18;
9721         spec->int_mic.pin = 0x19;
9722         spec->ext_mic.mux_idx = 0;
9723         spec->int_mic.mux_idx = 1;
9724         spec->auto_mic = 1;
9725 }
9726
9727 static struct hda_verb alc888_asus_eee1601_verbs[] = {
9728         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9729         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9730         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9731         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9732         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9733         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9734         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9735         /* enable unsolicited event */
9736         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9737         { } /* end */
9738 };
9739
9740 static void alc883_eee1601_inithook(struct hda_codec *codec)
9741 {
9742         struct alc_spec *spec = codec->spec;
9743
9744         spec->autocfg.hp_pins[0] = 0x14;
9745         spec->autocfg.speaker_pins[0] = 0x1b;
9746         alc_automute_pin(codec);
9747 }
9748
9749 static struct hda_verb alc889A_mb31_verbs[] = {
9750         /* Init rear pin (used as headphone output) */
9751         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9752         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9753         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9754         /* Init line pin (used as output in 4ch and 6ch mode) */
9755         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9756         /* Init line 2 pin (used as headphone out by default) */
9757         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9758         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9759         { } /* end */
9760 };
9761
9762 /* Mute speakers according to the headphone jack state */
9763 static void alc889A_mb31_automute(struct hda_codec *codec)
9764 {
9765         unsigned int present;
9766
9767         /* Mute only in 2ch or 4ch mode */
9768         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9769             == 0x00) {
9770                 present = snd_hda_jack_detect(codec, 0x15);
9771                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9772                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9773                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9774                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9775         }
9776 }
9777
9778 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
9779 {
9780         if ((res >> 26) == ALC880_HP_EVENT)
9781                 alc889A_mb31_automute(codec);
9782 }
9783
9784
9785 #ifdef CONFIG_SND_HDA_POWER_SAVE
9786 #define alc882_loopbacks        alc880_loopbacks
9787 #endif
9788
9789 /* pcm configuration: identical with ALC880 */
9790 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
9791 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
9792 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
9793 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
9794
9795 static hda_nid_t alc883_slave_dig_outs[] = {
9796         ALC1200_DIGOUT_NID, 0,
9797 };
9798
9799 static hda_nid_t alc1200_slave_dig_outs[] = {
9800         ALC883_DIGOUT_NID, 0,
9801 };
9802
9803 /*
9804  * configuration and preset
9805  */
9806 static const char * const alc882_models[ALC882_MODEL_LAST] = {
9807         [ALC882_3ST_DIG]        = "3stack-dig",
9808         [ALC882_6ST_DIG]        = "6stack-dig",
9809         [ALC882_ARIMA]          = "arima",
9810         [ALC882_W2JC]           = "w2jc",
9811         [ALC882_TARGA]          = "targa",
9812         [ALC882_ASUS_A7J]       = "asus-a7j",
9813         [ALC882_ASUS_A7M]       = "asus-a7m",
9814         [ALC885_MACPRO]         = "macpro",
9815         [ALC885_MB5]            = "mb5",
9816         [ALC885_MACMINI3]       = "macmini3",
9817         [ALC885_MBA21]          = "mba21",
9818         [ALC885_MBP3]           = "mbp3",
9819         [ALC885_IMAC24]         = "imac24",
9820         [ALC885_IMAC91]         = "imac91",
9821         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
9822         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
9823         [ALC883_3ST_6ch]        = "3stack-6ch",
9824         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
9825         [ALC883_TARGA_DIG]      = "targa-dig",
9826         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
9827         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
9828         [ALC883_ACER]           = "acer",
9829         [ALC883_ACER_ASPIRE]    = "acer-aspire",
9830         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
9831         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
9832         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
9833         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
9834         [ALC883_MEDION]         = "medion",
9835         [ALC883_MEDION_WIM2160] = "medion-wim2160",
9836         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
9837         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
9838         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
9839         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
9840         [ALC888_LENOVO_SKY] = "lenovo-sky",
9841         [ALC883_HAIER_W66]      = "haier-w66",
9842         [ALC888_3ST_HP]         = "3stack-hp",
9843         [ALC888_6ST_DELL]       = "6stack-dell",
9844         [ALC883_MITAC]          = "mitac",
9845         [ALC883_CLEVO_M540R]    = "clevo-m540r",
9846         [ALC883_CLEVO_M720]     = "clevo-m720",
9847         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
9848         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
9849         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
9850         [ALC889A_INTEL]         = "intel-alc889a",
9851         [ALC889_INTEL]          = "intel-x58",
9852         [ALC1200_ASUS_P5Q]      = "asus-p5q",
9853         [ALC889A_MB31]          = "mb31",
9854         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
9855         [ALC882_AUTO]           = "auto",
9856 };
9857
9858 static struct snd_pci_quirk alc882_cfg_tbl[] = {
9859         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
9860
9861         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
9862         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
9863         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
9864         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
9865         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
9866         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
9867         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
9868                 ALC888_ACER_ASPIRE_4930G),
9869         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
9870                 ALC888_ACER_ASPIRE_4930G),
9871         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
9872                 ALC888_ACER_ASPIRE_8930G),
9873         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
9874                 ALC888_ACER_ASPIRE_8930G),
9875         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
9876         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9877         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9878                 ALC888_ACER_ASPIRE_6530G),
9879         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9880                 ALC888_ACER_ASPIRE_6530G),
9881         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9882                 ALC888_ACER_ASPIRE_7730G),
9883         /* default Acer -- disabled as it causes more problems.
9884          *    model=auto should work fine now
9885          */
9886         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9887
9888         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9889
9890         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9891         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9892         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9893         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9894         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9895         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9896
9897         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9898         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9899         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9900         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9901         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9902         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9903         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9904         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9905         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9906         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9907         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9908
9909         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9910         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9911         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9912         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9913         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9914         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9915         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9916         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9917         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9918
9919         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9920         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9921         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9922         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9923         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9924         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9925         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9926         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9927         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9928         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9929         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9930         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9931         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9932         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9933         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9934         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9935         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9936         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9937         SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
9938         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9939         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9940         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9941         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9942         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9943         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9944         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9945         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9946         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9947         SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
9948         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9949         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9950
9951         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9952         SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG),
9953         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9954         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9955         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9956         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9957         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9958         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9959         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9960         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9961                       ALC883_FUJITSU_PI2515),
9962         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9963                 ALC888_FUJITSU_XA3530),
9964         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9965         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9966         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9967         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9968         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9969         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9970         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9971         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9972
9973         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9974         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9975         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9976         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9977         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9978         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9979         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
9980
9981         {}
9982 };
9983
9984 /* codec SSID table for Intel Mac */
9985 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9986         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9987         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9988         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9989         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9990         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9991         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9992         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9993         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31),
9994         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M),
9995         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3),
9996         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21),
9997         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9998         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9999         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
10000         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
10001         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
10002         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5),
10003         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
10004          * so apparently no perfect solution yet
10005          */
10006         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
10007         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
10008         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
10009         {} /* terminator */
10010 };
10011
10012 static struct alc_config_preset alc882_presets[] = {
10013         [ALC882_3ST_DIG] = {
10014                 .mixers = { alc882_base_mixer },
10015                 .init_verbs = { alc882_base_init_verbs,
10016                                 alc882_adc1_init_verbs },
10017                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10018                 .dac_nids = alc882_dac_nids,
10019                 .dig_out_nid = ALC882_DIGOUT_NID,
10020                 .dig_in_nid = ALC882_DIGIN_NID,
10021                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10022                 .channel_mode = alc882_ch_modes,
10023                 .need_dac_fix = 1,
10024                 .input_mux = &alc882_capture_source,
10025         },
10026         [ALC882_6ST_DIG] = {
10027                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
10028                 .init_verbs = { alc882_base_init_verbs,
10029                                 alc882_adc1_init_verbs },
10030                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10031                 .dac_nids = alc882_dac_nids,
10032                 .dig_out_nid = ALC882_DIGOUT_NID,
10033                 .dig_in_nid = ALC882_DIGIN_NID,
10034                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
10035                 .channel_mode = alc882_sixstack_modes,
10036                 .input_mux = &alc882_capture_source,
10037         },
10038         [ALC882_ARIMA] = {
10039                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
10040                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10041                                 alc882_eapd_verbs },
10042                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10043                 .dac_nids = alc882_dac_nids,
10044                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
10045                 .channel_mode = alc882_sixstack_modes,
10046                 .input_mux = &alc882_capture_source,
10047         },
10048         [ALC882_W2JC] = {
10049                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
10050                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10051                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
10052                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10053                 .dac_nids = alc882_dac_nids,
10054                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10055                 .channel_mode = alc880_threestack_modes,
10056                 .need_dac_fix = 1,
10057                 .input_mux = &alc882_capture_source,
10058                 .dig_out_nid = ALC882_DIGOUT_NID,
10059         },
10060            [ALC885_MBA21] = {
10061                         .mixers = { alc885_mba21_mixer },
10062                         .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
10063                         .num_dacs = 2,
10064                         .dac_nids = alc882_dac_nids,
10065                         .channel_mode = alc885_mba21_ch_modes,
10066                         .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10067                         .input_mux = &alc882_capture_source,
10068                         .unsol_event = alc_automute_amp_unsol_event,
10069                         .setup = alc885_mba21_setup,
10070                         .init_hook = alc_automute_amp,
10071        },
10072         [ALC885_MBP3] = {
10073                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
10074                 .init_verbs = { alc885_mbp3_init_verbs,
10075                                 alc880_gpio1_init_verbs },
10076                 .num_dacs = 2,
10077                 .dac_nids = alc882_dac_nids,
10078                 .hp_nid = 0x04,
10079                 .channel_mode = alc885_mbp_4ch_modes,
10080                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
10081                 .input_mux = &alc882_capture_source,
10082                 .dig_out_nid = ALC882_DIGOUT_NID,
10083                 .dig_in_nid = ALC882_DIGIN_NID,
10084                 .unsol_event = alc_automute_amp_unsol_event,
10085                 .setup = alc885_mbp3_setup,
10086                 .init_hook = alc_automute_amp,
10087         },
10088         [ALC885_MB5] = {
10089                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
10090                 .init_verbs = { alc885_mb5_init_verbs,
10091                                 alc880_gpio1_init_verbs },
10092                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10093                 .dac_nids = alc882_dac_nids,
10094                 .channel_mode = alc885_mb5_6ch_modes,
10095                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
10096                 .input_mux = &mb5_capture_source,
10097                 .dig_out_nid = ALC882_DIGOUT_NID,
10098                 .dig_in_nid = ALC882_DIGIN_NID,
10099                 .unsol_event = alc_automute_amp_unsol_event,
10100                 .setup = alc885_mb5_setup,
10101                 .init_hook = alc_automute_amp,
10102         },
10103         [ALC885_MACMINI3] = {
10104                 .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
10105                 .init_verbs = { alc885_macmini3_init_verbs,
10106                                 alc880_gpio1_init_verbs },
10107                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10108                 .dac_nids = alc882_dac_nids,
10109                 .channel_mode = alc885_macmini3_6ch_modes,
10110                 .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
10111                 .input_mux = &macmini3_capture_source,
10112                 .dig_out_nid = ALC882_DIGOUT_NID,
10113                 .dig_in_nid = ALC882_DIGIN_NID,
10114                 .unsol_event = alc_automute_amp_unsol_event,
10115                 .setup = alc885_macmini3_setup,
10116                 .init_hook = alc_automute_amp,
10117         },
10118         [ALC885_MACPRO] = {
10119                 .mixers = { alc882_macpro_mixer },
10120                 .init_verbs = { alc882_macpro_init_verbs },
10121                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10122                 .dac_nids = alc882_dac_nids,
10123                 .dig_out_nid = ALC882_DIGOUT_NID,
10124                 .dig_in_nid = ALC882_DIGIN_NID,
10125                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10126                 .channel_mode = alc882_ch_modes,
10127                 .input_mux = &alc882_capture_source,
10128                 .init_hook = alc885_macpro_init_hook,
10129         },
10130         [ALC885_IMAC24] = {
10131                 .mixers = { alc885_imac24_mixer },
10132                 .init_verbs = { alc885_imac24_init_verbs },
10133                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10134                 .dac_nids = alc882_dac_nids,
10135                 .dig_out_nid = ALC882_DIGOUT_NID,
10136                 .dig_in_nid = ALC882_DIGIN_NID,
10137                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10138                 .channel_mode = alc882_ch_modes,
10139                 .input_mux = &alc882_capture_source,
10140                 .unsol_event = alc_automute_amp_unsol_event,
10141                 .setup = alc885_imac24_setup,
10142                 .init_hook = alc885_imac24_init_hook,
10143         },
10144         [ALC885_IMAC91] = {
10145                 .mixers = {alc885_imac91_mixer},
10146                 .init_verbs = { alc885_imac91_init_verbs,
10147                                 alc880_gpio1_init_verbs },
10148                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10149                 .dac_nids = alc882_dac_nids,
10150                 .channel_mode = alc885_mba21_ch_modes,
10151                 .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10152                 .input_mux = &alc889A_imac91_capture_source,
10153                 .dig_out_nid = ALC882_DIGOUT_NID,
10154                 .dig_in_nid = ALC882_DIGIN_NID,
10155                 .unsol_event = alc_automute_amp_unsol_event,
10156                 .setup = alc885_imac91_setup,
10157                 .init_hook = alc_automute_amp,
10158         },
10159         [ALC882_TARGA] = {
10160                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
10161                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10162                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
10163                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10164                 .dac_nids = alc882_dac_nids,
10165                 .dig_out_nid = ALC882_DIGOUT_NID,
10166                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10167                 .adc_nids = alc882_adc_nids,
10168                 .capsrc_nids = alc882_capsrc_nids,
10169                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10170                 .channel_mode = alc882_3ST_6ch_modes,
10171                 .need_dac_fix = 1,
10172                 .input_mux = &alc882_capture_source,
10173                 .unsol_event = alc882_targa_unsol_event,
10174                 .setup = alc882_targa_setup,
10175                 .init_hook = alc882_targa_automute,
10176         },
10177         [ALC882_ASUS_A7J] = {
10178                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
10179                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10180                                 alc882_asus_a7j_verbs},
10181                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10182                 .dac_nids = alc882_dac_nids,
10183                 .dig_out_nid = ALC882_DIGOUT_NID,
10184                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10185                 .adc_nids = alc882_adc_nids,
10186                 .capsrc_nids = alc882_capsrc_nids,
10187                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10188                 .channel_mode = alc882_3ST_6ch_modes,
10189                 .need_dac_fix = 1,
10190                 .input_mux = &alc882_capture_source,
10191         },
10192         [ALC882_ASUS_A7M] = {
10193                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
10194                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10195                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
10196                                 alc882_asus_a7m_verbs },
10197                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10198                 .dac_nids = alc882_dac_nids,
10199                 .dig_out_nid = ALC882_DIGOUT_NID,
10200                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10201                 .channel_mode = alc880_threestack_modes,
10202                 .need_dac_fix = 1,
10203                 .input_mux = &alc882_capture_source,
10204         },
10205         [ALC883_3ST_2ch_DIG] = {
10206                 .mixers = { alc883_3ST_2ch_mixer },
10207                 .init_verbs = { alc883_init_verbs },
10208                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10209                 .dac_nids = alc883_dac_nids,
10210                 .dig_out_nid = ALC883_DIGOUT_NID,
10211                 .dig_in_nid = ALC883_DIGIN_NID,
10212                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10213                 .channel_mode = alc883_3ST_2ch_modes,
10214                 .input_mux = &alc883_capture_source,
10215         },
10216         [ALC883_3ST_6ch_DIG] = {
10217                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10218                 .init_verbs = { alc883_init_verbs },
10219                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10220                 .dac_nids = alc883_dac_nids,
10221                 .dig_out_nid = ALC883_DIGOUT_NID,
10222                 .dig_in_nid = ALC883_DIGIN_NID,
10223                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10224                 .channel_mode = alc883_3ST_6ch_modes,
10225                 .need_dac_fix = 1,
10226                 .input_mux = &alc883_capture_source,
10227         },
10228         [ALC883_3ST_6ch] = {
10229                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10230                 .init_verbs = { alc883_init_verbs },
10231                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10232                 .dac_nids = alc883_dac_nids,
10233                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10234                 .channel_mode = alc883_3ST_6ch_modes,
10235                 .need_dac_fix = 1,
10236                 .input_mux = &alc883_capture_source,
10237         },
10238         [ALC883_3ST_6ch_INTEL] = {
10239                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
10240                 .init_verbs = { alc883_init_verbs },
10241                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10242                 .dac_nids = alc883_dac_nids,
10243                 .dig_out_nid = ALC883_DIGOUT_NID,
10244                 .dig_in_nid = ALC883_DIGIN_NID,
10245                 .slave_dig_outs = alc883_slave_dig_outs,
10246                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
10247                 .channel_mode = alc883_3ST_6ch_intel_modes,
10248                 .need_dac_fix = 1,
10249                 .input_mux = &alc883_3stack_6ch_intel,
10250         },
10251         [ALC889A_INTEL] = {
10252                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10253                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
10254                                 alc_hp15_unsol_verbs },
10255                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10256                 .dac_nids = alc883_dac_nids,
10257                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10258                 .adc_nids = alc889_adc_nids,
10259                 .dig_out_nid = ALC883_DIGOUT_NID,
10260                 .dig_in_nid = ALC883_DIGIN_NID,
10261                 .slave_dig_outs = alc883_slave_dig_outs,
10262                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10263                 .channel_mode = alc889_8ch_intel_modes,
10264                 .capsrc_nids = alc889_capsrc_nids,
10265                 .input_mux = &alc889_capture_source,
10266                 .setup = alc889_automute_setup,
10267                 .init_hook = alc_automute_amp,
10268                 .unsol_event = alc_automute_amp_unsol_event,
10269                 .need_dac_fix = 1,
10270         },
10271         [ALC889_INTEL] = {
10272                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10273                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
10274                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
10275                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10276                 .dac_nids = alc883_dac_nids,
10277                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10278                 .adc_nids = alc889_adc_nids,
10279                 .dig_out_nid = ALC883_DIGOUT_NID,
10280                 .dig_in_nid = ALC883_DIGIN_NID,
10281                 .slave_dig_outs = alc883_slave_dig_outs,
10282                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10283                 .channel_mode = alc889_8ch_intel_modes,
10284                 .capsrc_nids = alc889_capsrc_nids,
10285                 .input_mux = &alc889_capture_source,
10286                 .setup = alc889_automute_setup,
10287                 .init_hook = alc889_intel_init_hook,
10288                 .unsol_event = alc_automute_amp_unsol_event,
10289                 .need_dac_fix = 1,
10290         },
10291         [ALC883_6ST_DIG] = {
10292                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10293                 .init_verbs = { alc883_init_verbs },
10294                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10295                 .dac_nids = alc883_dac_nids,
10296                 .dig_out_nid = ALC883_DIGOUT_NID,
10297                 .dig_in_nid = ALC883_DIGIN_NID,
10298                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10299                 .channel_mode = alc883_sixstack_modes,
10300                 .input_mux = &alc883_capture_source,
10301         },
10302         [ALC883_TARGA_DIG] = {
10303                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
10304                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10305                                 alc883_targa_verbs},
10306                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10307                 .dac_nids = alc883_dac_nids,
10308                 .dig_out_nid = ALC883_DIGOUT_NID,
10309                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10310                 .channel_mode = alc883_3ST_6ch_modes,
10311                 .need_dac_fix = 1,
10312                 .input_mux = &alc883_capture_source,
10313                 .unsol_event = alc883_targa_unsol_event,
10314                 .setup = alc882_targa_setup,
10315                 .init_hook = alc882_targa_automute,
10316         },
10317         [ALC883_TARGA_2ch_DIG] = {
10318                 .mixers = { alc883_targa_2ch_mixer},
10319                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10320                                 alc883_targa_verbs},
10321                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10322                 .dac_nids = alc883_dac_nids,
10323                 .adc_nids = alc883_adc_nids_alt,
10324                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10325                 .capsrc_nids = alc883_capsrc_nids,
10326                 .dig_out_nid = ALC883_DIGOUT_NID,
10327                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10328                 .channel_mode = alc883_3ST_2ch_modes,
10329                 .input_mux = &alc883_capture_source,
10330                 .unsol_event = alc883_targa_unsol_event,
10331                 .setup = alc882_targa_setup,
10332                 .init_hook = alc882_targa_automute,
10333         },
10334         [ALC883_TARGA_8ch_DIG] = {
10335                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
10336                             alc883_chmode_mixer },
10337                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10338                                 alc883_targa_verbs },
10339                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10340                 .dac_nids = alc883_dac_nids,
10341                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10342                 .adc_nids = alc883_adc_nids_rev,
10343                 .capsrc_nids = alc883_capsrc_nids_rev,
10344                 .dig_out_nid = ALC883_DIGOUT_NID,
10345                 .dig_in_nid = ALC883_DIGIN_NID,
10346                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
10347                 .channel_mode = alc883_4ST_8ch_modes,
10348                 .need_dac_fix = 1,
10349                 .input_mux = &alc883_capture_source,
10350                 .unsol_event = alc883_targa_unsol_event,
10351                 .setup = alc882_targa_setup,
10352                 .init_hook = alc882_targa_automute,
10353         },
10354         [ALC883_ACER] = {
10355                 .mixers = { alc883_base_mixer },
10356                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
10357                  * and the headphone jack.  Turn this on and rely on the
10358                  * standard mute methods whenever the user wants to turn
10359                  * these outputs off.
10360                  */
10361                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
10362                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10363                 .dac_nids = alc883_dac_nids,
10364                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10365                 .channel_mode = alc883_3ST_2ch_modes,
10366                 .input_mux = &alc883_capture_source,
10367         },
10368         [ALC883_ACER_ASPIRE] = {
10369                 .mixers = { alc883_acer_aspire_mixer },
10370                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
10371                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10372                 .dac_nids = alc883_dac_nids,
10373                 .dig_out_nid = ALC883_DIGOUT_NID,
10374                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10375                 .channel_mode = alc883_3ST_2ch_modes,
10376                 .input_mux = &alc883_capture_source,
10377                 .unsol_event = alc_automute_amp_unsol_event,
10378                 .setup = alc883_acer_aspire_setup,
10379                 .init_hook = alc_automute_amp,
10380         },
10381         [ALC888_ACER_ASPIRE_4930G] = {
10382                 .mixers = { alc888_acer_aspire_4930g_mixer,
10383                                 alc883_chmode_mixer },
10384                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10385                                 alc888_acer_aspire_4930g_verbs },
10386                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10387                 .dac_nids = alc883_dac_nids,
10388                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10389                 .adc_nids = alc883_adc_nids_rev,
10390                 .capsrc_nids = alc883_capsrc_nids_rev,
10391                 .dig_out_nid = ALC883_DIGOUT_NID,
10392                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10393                 .channel_mode = alc883_3ST_6ch_modes,
10394                 .need_dac_fix = 1,
10395                 .const_channel_count = 6,
10396                 .num_mux_defs =
10397                         ARRAY_SIZE(alc888_2_capture_sources),
10398                 .input_mux = alc888_2_capture_sources,
10399                 .unsol_event = alc_automute_amp_unsol_event,
10400                 .setup = alc888_acer_aspire_4930g_setup,
10401                 .init_hook = alc_automute_amp,
10402         },
10403         [ALC888_ACER_ASPIRE_6530G] = {
10404                 .mixers = { alc888_acer_aspire_6530_mixer },
10405                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10406                                 alc888_acer_aspire_6530g_verbs },
10407                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10408                 .dac_nids = alc883_dac_nids,
10409                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10410                 .adc_nids = alc883_adc_nids_rev,
10411                 .capsrc_nids = alc883_capsrc_nids_rev,
10412                 .dig_out_nid = ALC883_DIGOUT_NID,
10413                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10414                 .channel_mode = alc883_3ST_2ch_modes,
10415                 .num_mux_defs =
10416                         ARRAY_SIZE(alc888_2_capture_sources),
10417                 .input_mux = alc888_acer_aspire_6530_sources,
10418                 .unsol_event = alc_automute_amp_unsol_event,
10419                 .setup = alc888_acer_aspire_6530g_setup,
10420                 .init_hook = alc_automute_amp,
10421         },
10422         [ALC888_ACER_ASPIRE_8930G] = {
10423                 .mixers = { alc889_acer_aspire_8930g_mixer,
10424                                 alc883_chmode_mixer },
10425                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10426                                 alc889_acer_aspire_8930g_verbs,
10427                                 alc889_eapd_verbs},
10428                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10429                 .dac_nids = alc883_dac_nids,
10430                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10431                 .adc_nids = alc889_adc_nids,
10432                 .capsrc_nids = alc889_capsrc_nids,
10433                 .dig_out_nid = ALC883_DIGOUT_NID,
10434                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10435                 .channel_mode = alc883_3ST_6ch_modes,
10436                 .need_dac_fix = 1,
10437                 .const_channel_count = 6,
10438                 .num_mux_defs =
10439                         ARRAY_SIZE(alc889_capture_sources),
10440                 .input_mux = alc889_capture_sources,
10441                 .unsol_event = alc_automute_amp_unsol_event,
10442                 .setup = alc889_acer_aspire_8930g_setup,
10443                 .init_hook = alc_automute_amp,
10444 #ifdef CONFIG_SND_HDA_POWER_SAVE
10445                 .power_hook = alc_power_eapd,
10446 #endif
10447         },
10448         [ALC888_ACER_ASPIRE_7730G] = {
10449                 .mixers = { alc883_3ST_6ch_mixer,
10450                                 alc883_chmode_mixer },
10451                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10452                                 alc888_acer_aspire_7730G_verbs },
10453                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10454                 .dac_nids = alc883_dac_nids,
10455                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10456                 .adc_nids = alc883_adc_nids_rev,
10457                 .capsrc_nids = alc883_capsrc_nids_rev,
10458                 .dig_out_nid = ALC883_DIGOUT_NID,
10459                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10460                 .channel_mode = alc883_3ST_6ch_modes,
10461                 .need_dac_fix = 1,
10462                 .const_channel_count = 6,
10463                 .input_mux = &alc883_capture_source,
10464                 .unsol_event = alc_automute_amp_unsol_event,
10465                 .setup = alc888_acer_aspire_7730g_setup,
10466                 .init_hook = alc_automute_amp,
10467         },
10468         [ALC883_MEDION] = {
10469                 .mixers = { alc883_fivestack_mixer,
10470                             alc883_chmode_mixer },
10471                 .init_verbs = { alc883_init_verbs,
10472                                 alc883_medion_eapd_verbs },
10473                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10474                 .dac_nids = alc883_dac_nids,
10475                 .adc_nids = alc883_adc_nids_alt,
10476                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10477                 .capsrc_nids = alc883_capsrc_nids,
10478                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10479                 .channel_mode = alc883_sixstack_modes,
10480                 .input_mux = &alc883_capture_source,
10481         },
10482         [ALC883_MEDION_WIM2160] = {
10483                 .mixers = { alc883_medion_wim2160_mixer },
10484                 .init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
10485                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10486                 .dac_nids = alc883_dac_nids,
10487                 .dig_out_nid = ALC883_DIGOUT_NID,
10488                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10489                 .adc_nids = alc883_adc_nids,
10490                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10491                 .channel_mode = alc883_3ST_2ch_modes,
10492                 .input_mux = &alc883_capture_source,
10493                 .unsol_event = alc_automute_amp_unsol_event,
10494                 .setup = alc883_medion_wim2160_setup,
10495                 .init_hook = alc_automute_amp,
10496         },
10497         [ALC883_LAPTOP_EAPD] = {
10498                 .mixers = { alc883_base_mixer },
10499                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
10500                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10501                 .dac_nids = alc883_dac_nids,
10502                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10503                 .channel_mode = alc883_3ST_2ch_modes,
10504                 .input_mux = &alc883_capture_source,
10505         },
10506         [ALC883_CLEVO_M540R] = {
10507                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10508                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
10509                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10510                 .dac_nids = alc883_dac_nids,
10511                 .dig_out_nid = ALC883_DIGOUT_NID,
10512                 .dig_in_nid = ALC883_DIGIN_NID,
10513                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
10514                 .channel_mode = alc883_3ST_6ch_clevo_modes,
10515                 .need_dac_fix = 1,
10516                 .input_mux = &alc883_capture_source,
10517                 /* This machine has the hardware HP auto-muting, thus
10518                  * we need no software mute via unsol event
10519                  */
10520         },
10521         [ALC883_CLEVO_M720] = {
10522                 .mixers = { alc883_clevo_m720_mixer },
10523                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
10524                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10525                 .dac_nids = alc883_dac_nids,
10526                 .dig_out_nid = ALC883_DIGOUT_NID,
10527                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10528                 .channel_mode = alc883_3ST_2ch_modes,
10529                 .input_mux = &alc883_capture_source,
10530                 .unsol_event = alc883_clevo_m720_unsol_event,
10531                 .setup = alc883_clevo_m720_setup,
10532                 .init_hook = alc883_clevo_m720_init_hook,
10533         },
10534         [ALC883_LENOVO_101E_2ch] = {
10535                 .mixers = { alc883_lenovo_101e_2ch_mixer},
10536                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
10537                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10538                 .dac_nids = alc883_dac_nids,
10539                 .adc_nids = alc883_adc_nids_alt,
10540                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10541                 .capsrc_nids = alc883_capsrc_nids,
10542                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10543                 .channel_mode = alc883_3ST_2ch_modes,
10544                 .input_mux = &alc883_lenovo_101e_capture_source,
10545                 .unsol_event = alc883_lenovo_101e_unsol_event,
10546                 .init_hook = alc883_lenovo_101e_all_automute,
10547         },
10548         [ALC883_LENOVO_NB0763] = {
10549                 .mixers = { alc883_lenovo_nb0763_mixer },
10550                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
10551                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10552                 .dac_nids = alc883_dac_nids,
10553                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10554                 .channel_mode = alc883_3ST_2ch_modes,
10555                 .need_dac_fix = 1,
10556                 .input_mux = &alc883_lenovo_nb0763_capture_source,
10557                 .unsol_event = alc_automute_amp_unsol_event,
10558                 .setup = alc883_lenovo_nb0763_setup,
10559                 .init_hook = alc_automute_amp,
10560         },
10561         [ALC888_LENOVO_MS7195_DIG] = {
10562                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10563                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
10564                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10565                 .dac_nids = alc883_dac_nids,
10566                 .dig_out_nid = ALC883_DIGOUT_NID,
10567                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10568                 .channel_mode = alc883_3ST_6ch_modes,
10569                 .need_dac_fix = 1,
10570                 .input_mux = &alc883_capture_source,
10571                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
10572                 .init_hook = alc888_lenovo_ms7195_front_automute,
10573         },
10574         [ALC883_HAIER_W66] = {
10575                 .mixers = { alc883_targa_2ch_mixer},
10576                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
10577                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10578                 .dac_nids = alc883_dac_nids,
10579                 .dig_out_nid = ALC883_DIGOUT_NID,
10580                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10581                 .channel_mode = alc883_3ST_2ch_modes,
10582                 .input_mux = &alc883_capture_source,
10583                 .unsol_event = alc_automute_amp_unsol_event,
10584                 .setup = alc883_haier_w66_setup,
10585                 .init_hook = alc_automute_amp,
10586         },
10587         [ALC888_3ST_HP] = {
10588                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10589                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
10590                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10591                 .dac_nids = alc883_dac_nids,
10592                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
10593                 .channel_mode = alc888_3st_hp_modes,
10594                 .need_dac_fix = 1,
10595                 .input_mux = &alc883_capture_source,
10596                 .unsol_event = alc_automute_amp_unsol_event,
10597                 .setup = alc888_3st_hp_setup,
10598                 .init_hook = alc_automute_amp,
10599         },
10600         [ALC888_6ST_DELL] = {
10601                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10602                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
10603                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10604                 .dac_nids = alc883_dac_nids,
10605                 .dig_out_nid = ALC883_DIGOUT_NID,
10606                 .dig_in_nid = ALC883_DIGIN_NID,
10607                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10608                 .channel_mode = alc883_sixstack_modes,
10609                 .input_mux = &alc883_capture_source,
10610                 .unsol_event = alc_automute_amp_unsol_event,
10611                 .setup = alc888_6st_dell_setup,
10612                 .init_hook = alc_automute_amp,
10613         },
10614         [ALC883_MITAC] = {
10615                 .mixers = { alc883_mitac_mixer },
10616                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
10617                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10618                 .dac_nids = alc883_dac_nids,
10619                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10620                 .channel_mode = alc883_3ST_2ch_modes,
10621                 .input_mux = &alc883_capture_source,
10622                 .unsol_event = alc_automute_amp_unsol_event,
10623                 .setup = alc883_mitac_setup,
10624                 .init_hook = alc_automute_amp,
10625         },
10626         [ALC883_FUJITSU_PI2515] = {
10627                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
10628                 .init_verbs = { alc883_init_verbs,
10629                                 alc883_2ch_fujitsu_pi2515_verbs},
10630                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10631                 .dac_nids = alc883_dac_nids,
10632                 .dig_out_nid = ALC883_DIGOUT_NID,
10633                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10634                 .channel_mode = alc883_3ST_2ch_modes,
10635                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10636                 .unsol_event = alc_automute_amp_unsol_event,
10637                 .setup = alc883_2ch_fujitsu_pi2515_setup,
10638                 .init_hook = alc_automute_amp,
10639         },
10640         [ALC888_FUJITSU_XA3530] = {
10641                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
10642                 .init_verbs = { alc883_init_verbs,
10643                         alc888_fujitsu_xa3530_verbs },
10644                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10645                 .dac_nids = alc883_dac_nids,
10646                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10647                 .adc_nids = alc883_adc_nids_rev,
10648                 .capsrc_nids = alc883_capsrc_nids_rev,
10649                 .dig_out_nid = ALC883_DIGOUT_NID,
10650                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
10651                 .channel_mode = alc888_4ST_8ch_intel_modes,
10652                 .num_mux_defs =
10653                         ARRAY_SIZE(alc888_2_capture_sources),
10654                 .input_mux = alc888_2_capture_sources,
10655                 .unsol_event = alc_automute_amp_unsol_event,
10656                 .setup = alc888_fujitsu_xa3530_setup,
10657                 .init_hook = alc_automute_amp,
10658         },
10659         [ALC888_LENOVO_SKY] = {
10660                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
10661                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
10662                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10663                 .dac_nids = alc883_dac_nids,
10664                 .dig_out_nid = ALC883_DIGOUT_NID,
10665                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10666                 .channel_mode = alc883_sixstack_modes,
10667                 .need_dac_fix = 1,
10668                 .input_mux = &alc883_lenovo_sky_capture_source,
10669                 .unsol_event = alc_automute_amp_unsol_event,
10670                 .setup = alc888_lenovo_sky_setup,
10671                 .init_hook = alc_automute_amp,
10672         },
10673         [ALC888_ASUS_M90V] = {
10674                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10675                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10676                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10677                 .dac_nids = alc883_dac_nids,
10678                 .dig_out_nid = ALC883_DIGOUT_NID,
10679                 .dig_in_nid = ALC883_DIGIN_NID,
10680                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10681                 .channel_mode = alc883_3ST_6ch_modes,
10682                 .need_dac_fix = 1,
10683                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10684                 .unsol_event = alc_sku_unsol_event,
10685                 .setup = alc883_mode2_setup,
10686                 .init_hook = alc_inithook,
10687         },
10688         [ALC888_ASUS_EEE1601] = {
10689                 .mixers = { alc883_asus_eee1601_mixer },
10690                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
10691                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10692                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10693                 .dac_nids = alc883_dac_nids,
10694                 .dig_out_nid = ALC883_DIGOUT_NID,
10695                 .dig_in_nid = ALC883_DIGIN_NID,
10696                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10697                 .channel_mode = alc883_3ST_2ch_modes,
10698                 .need_dac_fix = 1,
10699                 .input_mux = &alc883_asus_eee1601_capture_source,
10700                 .unsol_event = alc_sku_unsol_event,
10701                 .init_hook = alc883_eee1601_inithook,
10702         },
10703         [ALC1200_ASUS_P5Q] = {
10704                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10705                 .init_verbs = { alc883_init_verbs },
10706                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10707                 .dac_nids = alc883_dac_nids,
10708                 .dig_out_nid = ALC1200_DIGOUT_NID,
10709                 .dig_in_nid = ALC883_DIGIN_NID,
10710                 .slave_dig_outs = alc1200_slave_dig_outs,
10711                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10712                 .channel_mode = alc883_sixstack_modes,
10713                 .input_mux = &alc883_capture_source,
10714         },
10715         [ALC889A_MB31] = {
10716                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10717                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10718                         alc880_gpio1_init_verbs },
10719                 .adc_nids = alc883_adc_nids,
10720                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10721                 .capsrc_nids = alc883_capsrc_nids,
10722                 .dac_nids = alc883_dac_nids,
10723                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10724                 .channel_mode = alc889A_mb31_6ch_modes,
10725                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10726                 .input_mux = &alc889A_mb31_capture_source,
10727                 .dig_out_nid = ALC883_DIGOUT_NID,
10728                 .unsol_event = alc889A_mb31_unsol_event,
10729                 .init_hook = alc889A_mb31_automute,
10730         },
10731         [ALC883_SONY_VAIO_TT] = {
10732                 .mixers = { alc883_vaiott_mixer },
10733                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10734                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10735                 .dac_nids = alc883_dac_nids,
10736                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10737                 .channel_mode = alc883_3ST_2ch_modes,
10738                 .input_mux = &alc883_capture_source,
10739                 .unsol_event = alc_automute_amp_unsol_event,
10740                 .setup = alc883_vaiott_setup,
10741                 .init_hook = alc_automute_amp,
10742         },
10743 };
10744
10745
10746 /*
10747  * Pin config fixes
10748  */
10749 enum {
10750         PINFIX_ABIT_AW9D_MAX,
10751         PINFIX_PB_M5210,
10752         PINFIX_ACER_ASPIRE_7736,
10753 };
10754
10755 static const struct alc_fixup alc882_fixups[] = {
10756         [PINFIX_ABIT_AW9D_MAX] = {
10757                 .type = ALC_FIXUP_PINS,
10758                 .v.pins = (const struct alc_pincfg[]) {
10759                         { 0x15, 0x01080104 }, /* side */
10760                         { 0x16, 0x01011012 }, /* rear */
10761                         { 0x17, 0x01016011 }, /* clfe */
10762                         { }
10763                 }
10764         },
10765         [PINFIX_PB_M5210] = {
10766                 .type = ALC_FIXUP_VERBS,
10767                 .v.verbs = (const struct hda_verb[]) {
10768                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
10769                         {}
10770                 }
10771         },
10772         [PINFIX_ACER_ASPIRE_7736] = {
10773                 .type = ALC_FIXUP_SKU,
10774                 .v.sku = ALC_FIXUP_SKU_IGNORE,
10775         },
10776 };
10777
10778 static struct snd_pci_quirk alc882_fixup_tbl[] = {
10779         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
10780         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
10781         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
10782         {}
10783 };
10784
10785 /*
10786  * BIOS auto configuration
10787  */
10788 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
10789                                                 const struct auto_pin_cfg *cfg)
10790 {
10791         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
10792 }
10793
10794 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
10795                                               hda_nid_t nid, int pin_type,
10796                                               hda_nid_t dac)
10797 {
10798         int idx;
10799
10800         /* set as output */
10801         alc_set_pin_output(codec, nid, pin_type);
10802
10803         if (dac == 0x25)
10804                 idx = 4;
10805         else if (dac >= 0x02 && dac <= 0x05)
10806                 idx = dac - 2;
10807         else
10808                 return;
10809         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
10810 }
10811
10812 static void alc882_auto_init_multi_out(struct hda_codec *codec)
10813 {
10814         struct alc_spec *spec = codec->spec;
10815         int i;
10816
10817         for (i = 0; i <= HDA_SIDE; i++) {
10818                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
10819                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
10820                 if (nid)
10821                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
10822                                         spec->multiout.dac_nids[i]);
10823         }
10824 }
10825
10826 static void alc882_auto_init_hp_out(struct hda_codec *codec)
10827 {
10828         struct alc_spec *spec = codec->spec;
10829         hda_nid_t pin, dac;
10830         int i;
10831
10832         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
10833                 pin = spec->autocfg.hp_pins[i];
10834                 if (!pin)
10835                         break;
10836                 dac = spec->multiout.hp_nid;
10837                 if (!dac)
10838                         dac = spec->multiout.dac_nids[0]; /* to front */
10839                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
10840         }
10841         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
10842                 pin = spec->autocfg.speaker_pins[i];
10843                 if (!pin)
10844                         break;
10845                 dac = spec->multiout.extra_out_nid[0];
10846                 if (!dac)
10847                         dac = spec->multiout.dac_nids[0]; /* to front */
10848                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
10849         }
10850 }
10851
10852 static void alc882_auto_init_analog_input(struct hda_codec *codec)
10853 {
10854         struct alc_spec *spec = codec->spec;
10855         struct auto_pin_cfg *cfg = &spec->autocfg;
10856         int i;
10857
10858         for (i = 0; i < cfg->num_inputs; i++) {
10859                 hda_nid_t nid = cfg->inputs[i].pin;
10860                 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
10861                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
10862                         snd_hda_codec_write(codec, nid, 0,
10863                                             AC_VERB_SET_AMP_GAIN_MUTE,
10864                                             AMP_OUT_MUTE);
10865         }
10866 }
10867
10868 static void alc882_auto_init_input_src(struct hda_codec *codec)
10869 {
10870         struct alc_spec *spec = codec->spec;
10871         int c;
10872
10873         for (c = 0; c < spec->num_adc_nids; c++) {
10874                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
10875                 hda_nid_t nid = spec->capsrc_nids[c];
10876                 unsigned int mux_idx;
10877                 const struct hda_input_mux *imux;
10878                 int conns, mute, idx, item;
10879
10880                 conns = snd_hda_get_connections(codec, nid, conn_list,
10881                                                 ARRAY_SIZE(conn_list));
10882                 if (conns < 0)
10883                         continue;
10884                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
10885                 imux = &spec->input_mux[mux_idx];
10886                 if (!imux->num_items && mux_idx > 0)
10887                         imux = &spec->input_mux[0];
10888                 for (idx = 0; idx < conns; idx++) {
10889                         /* if the current connection is the selected one,
10890                          * unmute it as default - otherwise mute it
10891                          */
10892                         mute = AMP_IN_MUTE(idx);
10893                         for (item = 0; item < imux->num_items; item++) {
10894                                 if (imux->items[item].index == idx) {
10895                                         if (spec->cur_mux[c] == item)
10896                                                 mute = AMP_IN_UNMUTE(idx);
10897                                         break;
10898                                 }
10899                         }
10900                         /* check if we have a selector or mixer
10901                          * we could check for the widget type instead, but
10902                          * just check for Amp-In presence (in case of mixer
10903                          * without amp-in there is something wrong, this
10904                          * function shouldn't be used or capsrc nid is wrong)
10905                          */
10906                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
10907                                 snd_hda_codec_write(codec, nid, 0,
10908                                                     AC_VERB_SET_AMP_GAIN_MUTE,
10909                                                     mute);
10910                         else if (mute != AMP_IN_MUTE(idx))
10911                                 snd_hda_codec_write(codec, nid, 0,
10912                                                     AC_VERB_SET_CONNECT_SEL,
10913                                                     idx);
10914                 }
10915         }
10916 }
10917
10918 /* add mic boosts if needed */
10919 static int alc_auto_add_mic_boost(struct hda_codec *codec)
10920 {
10921         struct alc_spec *spec = codec->spec;
10922         struct auto_pin_cfg *cfg = &spec->autocfg;
10923         int i, err;
10924         int type_idx = 0;
10925         hda_nid_t nid;
10926         const char *prev_label = NULL;
10927
10928         for (i = 0; i < cfg->num_inputs; i++) {
10929                 if (cfg->inputs[i].type > AUTO_PIN_MIC)
10930                         break;
10931                 nid = cfg->inputs[i].pin;
10932                 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
10933                         const char *label;
10934                         char boost_label[32];
10935
10936                         label = hda_get_autocfg_input_label(codec, cfg, i);
10937                         if (prev_label && !strcmp(label, prev_label))
10938                                 type_idx++;
10939                         else
10940                                 type_idx = 0;
10941                         prev_label = label;
10942
10943                         snprintf(boost_label, sizeof(boost_label),
10944                                  "%s Boost Volume", label);
10945                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10946                                           boost_label, type_idx,
10947                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10948                         if (err < 0)
10949                                 return err;
10950                 }
10951         }
10952         return 0;
10953 }
10954
10955 /* almost identical with ALC880 parser... */
10956 static int alc882_parse_auto_config(struct hda_codec *codec)
10957 {
10958         struct alc_spec *spec = codec->spec;
10959         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10960         int err;
10961
10962         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10963                                            alc882_ignore);
10964         if (err < 0)
10965                 return err;
10966         if (!spec->autocfg.line_outs)
10967                 return 0; /* can't find valid BIOS pin config */
10968
10969         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10970         if (err < 0)
10971                 return err;
10972         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10973         if (err < 0)
10974                 return err;
10975         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10976                                            "Headphone");
10977         if (err < 0)
10978                 return err;
10979         err = alc880_auto_create_extra_out(spec,
10980                                            spec->autocfg.speaker_pins[0],
10981                                            "Speaker");
10982         if (err < 0)
10983                 return err;
10984         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10985         if (err < 0)
10986                 return err;
10987
10988         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10989
10990         alc_auto_parse_digital(codec);
10991
10992         if (spec->kctls.list)
10993                 add_mixer(spec, spec->kctls.list);
10994
10995         add_verb(spec, alc883_auto_init_verbs);
10996         /* if ADC 0x07 is available, initialize it, too */
10997         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10998                 add_verb(spec, alc882_adc1_init_verbs);
10999
11000         spec->num_mux_defs = 1;
11001         spec->input_mux = &spec->private_imux[0];
11002
11003         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
11004
11005         err = alc_auto_add_mic_boost(codec);
11006         if (err < 0)
11007                 return err;
11008
11009         return 1; /* config found */
11010 }
11011
11012 /* additional initialization for auto-configuration model */
11013 static void alc882_auto_init(struct hda_codec *codec)
11014 {
11015         struct alc_spec *spec = codec->spec;
11016         alc882_auto_init_multi_out(codec);
11017         alc882_auto_init_hp_out(codec);
11018         alc882_auto_init_analog_input(codec);
11019         alc882_auto_init_input_src(codec);
11020         alc_auto_init_digital(codec);
11021         if (spec->unsol_event)
11022                 alc_inithook(codec);
11023 }
11024
11025 static int patch_alc882(struct hda_codec *codec)
11026 {
11027         struct alc_spec *spec;
11028         int err, board_config;
11029
11030         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11031         if (spec == NULL)
11032                 return -ENOMEM;
11033
11034         codec->spec = spec;
11035
11036         switch (codec->vendor_id) {
11037         case 0x10ec0882:
11038         case 0x10ec0885:
11039                 break;
11040         default:
11041                 /* ALC883 and variants */
11042                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11043                 break;
11044         }
11045
11046         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
11047                                                   alc882_models,
11048                                                   alc882_cfg_tbl);
11049
11050         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
11051                 board_config = snd_hda_check_board_codec_sid_config(codec,
11052                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
11053
11054         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
11055                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
11056                        codec->chip_name);
11057                 board_config = ALC882_AUTO;
11058         }
11059
11060         if (board_config == ALC882_AUTO) {
11061                 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
11062                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
11063         }
11064
11065         alc_auto_parse_customize_define(codec);
11066
11067         if (board_config == ALC882_AUTO) {
11068                 /* automatic parse from the BIOS config */
11069                 err = alc882_parse_auto_config(codec);
11070                 if (err < 0) {
11071                         alc_free(codec);
11072                         return err;
11073                 } else if (!err) {
11074                         printk(KERN_INFO
11075                                "hda_codec: Cannot set up configuration "
11076                                "from BIOS.  Using base mode...\n");
11077                         board_config = ALC882_3ST_DIG;
11078                 }
11079         }
11080
11081         if (has_cdefine_beep(codec)) {
11082                 err = snd_hda_attach_beep_device(codec, 0x1);
11083                 if (err < 0) {
11084                         alc_free(codec);
11085                         return err;
11086                 }
11087         }
11088
11089         if (board_config != ALC882_AUTO)
11090                 setup_preset(codec, &alc882_presets[board_config]);
11091
11092         spec->stream_analog_playback = &alc882_pcm_analog_playback;
11093         spec->stream_analog_capture = &alc882_pcm_analog_capture;
11094         /* FIXME: setup DAC5 */
11095         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
11096         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
11097
11098         spec->stream_digital_playback = &alc882_pcm_digital_playback;
11099         spec->stream_digital_capture = &alc882_pcm_digital_capture;
11100
11101         if (!spec->adc_nids && spec->input_mux) {
11102                 int i, j;
11103                 spec->num_adc_nids = 0;
11104                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
11105                         const struct hda_input_mux *imux = spec->input_mux;
11106                         hda_nid_t cap;
11107                         hda_nid_t items[16];
11108                         hda_nid_t nid = alc882_adc_nids[i];
11109                         unsigned int wcap = get_wcaps(codec, nid);
11110                         /* get type */
11111                         wcap = get_wcaps_type(wcap);
11112                         if (wcap != AC_WID_AUD_IN)
11113                                 continue;
11114                         spec->private_adc_nids[spec->num_adc_nids] = nid;
11115                         err = snd_hda_get_connections(codec, nid, &cap, 1);
11116                         if (err < 0)
11117                                 continue;
11118                         err = snd_hda_get_connections(codec, cap, items,
11119                                                       ARRAY_SIZE(items));
11120                         if (err < 0)
11121                                 continue;
11122                         for (j = 0; j < imux->num_items; j++)
11123                                 if (imux->items[j].index >= err)
11124                                         break;
11125                         if (j < imux->num_items)
11126                                 continue;
11127                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
11128                         spec->num_adc_nids++;
11129                 }
11130                 spec->adc_nids = spec->private_adc_nids;
11131                 spec->capsrc_nids = spec->private_capsrc_nids;
11132         }
11133
11134         set_capture_mixer(codec);
11135
11136         if (has_cdefine_beep(codec))
11137                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11138
11139         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
11140
11141         spec->vmaster_nid = 0x0c;
11142
11143         codec->patch_ops = alc_patch_ops;
11144         if (board_config == ALC882_AUTO)
11145                 spec->init_hook = alc882_auto_init;
11146
11147         alc_init_jacks(codec);
11148 #ifdef CONFIG_SND_HDA_POWER_SAVE
11149         if (!spec->loopback.amplist)
11150                 spec->loopback.amplist = alc882_loopbacks;
11151 #endif
11152
11153         return 0;
11154 }
11155
11156
11157 /*
11158  * ALC262 support
11159  */
11160
11161 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
11162 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
11163
11164 #define alc262_dac_nids         alc260_dac_nids
11165 #define alc262_adc_nids         alc882_adc_nids
11166 #define alc262_adc_nids_alt     alc882_adc_nids_alt
11167 #define alc262_capsrc_nids      alc882_capsrc_nids
11168 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
11169
11170 #define alc262_modes            alc260_modes
11171 #define alc262_capture_source   alc882_capture_source
11172
11173 static hda_nid_t alc262_dmic_adc_nids[1] = {
11174         /* ADC0 */
11175         0x09
11176 };
11177
11178 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
11179
11180 static struct snd_kcontrol_new alc262_base_mixer[] = {
11181         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11182         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11183         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11184         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11185         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11186         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11187         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11188         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11189         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11190         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11191         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11192         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11193         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
11194         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11195         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
11196         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11197         { } /* end */
11198 };
11199
11200 /* update HP, line and mono-out pins according to the master switch */
11201 static void alc262_hp_master_update(struct hda_codec *codec)
11202 {
11203         struct alc_spec *spec = codec->spec;
11204         int val = spec->master_sw;
11205
11206         /* HP & line-out */
11207         snd_hda_codec_write_cache(codec, 0x1b, 0,
11208                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11209                                   val ? PIN_HP : 0);
11210         snd_hda_codec_write_cache(codec, 0x15, 0,
11211                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11212                                   val ? PIN_HP : 0);
11213         /* mono (speaker) depending on the HP jack sense */
11214         val = val && !spec->jack_present;
11215         snd_hda_codec_write_cache(codec, 0x16, 0,
11216                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11217                                   val ? PIN_OUT : 0);
11218 }
11219
11220 static void alc262_hp_bpc_automute(struct hda_codec *codec)
11221 {
11222         struct alc_spec *spec = codec->spec;
11223
11224         spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11225         alc262_hp_master_update(codec);
11226 }
11227
11228 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
11229 {
11230         if ((res >> 26) != ALC880_HP_EVENT)
11231                 return;
11232         alc262_hp_bpc_automute(codec);
11233 }
11234
11235 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
11236 {
11237         struct alc_spec *spec = codec->spec;
11238
11239         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11240         alc262_hp_master_update(codec);
11241 }
11242
11243 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
11244                                            unsigned int res)
11245 {
11246         if ((res >> 26) != ALC880_HP_EVENT)
11247                 return;
11248         alc262_hp_wildwest_automute(codec);
11249 }
11250
11251 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
11252
11253 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
11254                                    struct snd_ctl_elem_value *ucontrol)
11255 {
11256         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11257         struct alc_spec *spec = codec->spec;
11258         int val = !!*ucontrol->value.integer.value;
11259
11260         if (val == spec->master_sw)
11261                 return 0;
11262         spec->master_sw = val;
11263         alc262_hp_master_update(codec);
11264         return 1;
11265 }
11266
11267 #define ALC262_HP_MASTER_SWITCH                                 \
11268         {                                                       \
11269                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11270                 .name = "Master Playback Switch",               \
11271                 .info = snd_ctl_boolean_mono_info,              \
11272                 .get = alc262_hp_master_sw_get,                 \
11273                 .put = alc262_hp_master_sw_put,                 \
11274         }, \
11275         {                                                       \
11276                 .iface = NID_MAPPING,                           \
11277                 .name = "Master Playback Switch",               \
11278                 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
11279         }
11280
11281
11282 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
11283         ALC262_HP_MASTER_SWITCH,
11284         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11285         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11286         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11287         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11288                               HDA_OUTPUT),
11289         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11290                             HDA_OUTPUT),
11291         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11292         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11293         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11294         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11295         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11296         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11297         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11298         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11299         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11300         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11301         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
11302         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
11303         { } /* end */
11304 };
11305
11306 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
11307         ALC262_HP_MASTER_SWITCH,
11308         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11309         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11310         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11311         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11312         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11313                               HDA_OUTPUT),
11314         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11315                             HDA_OUTPUT),
11316         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
11317         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
11318         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x1a, 0, HDA_INPUT),
11319         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11320         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11321         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11322         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11323         { } /* end */
11324 };
11325
11326 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
11327         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11328         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11329         HDA_CODEC_VOLUME("Rear Mic Boost Volume", 0x18, 0, HDA_INPUT),
11330         { } /* end */
11331 };
11332
11333 /* mute/unmute internal speaker according to the hp jack and mute state */
11334 static void alc262_hp_t5735_setup(struct hda_codec *codec)
11335 {
11336         struct alc_spec *spec = codec->spec;
11337
11338         spec->autocfg.hp_pins[0] = 0x15;
11339         spec->autocfg.speaker_pins[0] = 0x14;
11340 }
11341
11342 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
11343         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11344         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11345         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11346         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11347         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11348         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11349         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11350         { } /* end */
11351 };
11352
11353 static struct hda_verb alc262_hp_t5735_verbs[] = {
11354         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11355         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11356
11357         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11358         { }
11359 };
11360
11361 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
11362         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11363         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11364         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
11365         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
11366         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11367         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11368         { } /* end */
11369 };
11370
11371 static struct hda_verb alc262_hp_rp5700_verbs[] = {
11372         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11373         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11374         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11375         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11376         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11377         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11378         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11379         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11380         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11381         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11382         {}
11383 };
11384
11385 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
11386         .num_items = 1,
11387         .items = {
11388                 { "Line", 0x1 },
11389         },
11390 };
11391
11392 /* bind hp and internal speaker mute (with plug check) as master switch */
11393 static void alc262_hippo_master_update(struct hda_codec *codec)
11394 {
11395         struct alc_spec *spec = codec->spec;
11396         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11397         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11398         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11399         unsigned int mute;
11400
11401         /* HP */
11402         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
11403         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
11404                                  HDA_AMP_MUTE, mute);
11405         /* mute internal speaker per jack sense */
11406         if (spec->jack_present)
11407                 mute = HDA_AMP_MUTE;
11408         if (line_nid)
11409                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
11410                                          HDA_AMP_MUTE, mute);
11411         if (speaker_nid && speaker_nid != line_nid)
11412                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
11413                                          HDA_AMP_MUTE, mute);
11414 }
11415
11416 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
11417
11418 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
11419                                       struct snd_ctl_elem_value *ucontrol)
11420 {
11421         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11422         struct alc_spec *spec = codec->spec;
11423         int val = !!*ucontrol->value.integer.value;
11424
11425         if (val == spec->master_sw)
11426                 return 0;
11427         spec->master_sw = val;
11428         alc262_hippo_master_update(codec);
11429         return 1;
11430 }
11431
11432 #define ALC262_HIPPO_MASTER_SWITCH                              \
11433         {                                                       \
11434                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11435                 .name = "Master Playback Switch",               \
11436                 .info = snd_ctl_boolean_mono_info,              \
11437                 .get = alc262_hippo_master_sw_get,              \
11438                 .put = alc262_hippo_master_sw_put,              \
11439         },                                                      \
11440         {                                                       \
11441                 .iface = NID_MAPPING,                           \
11442                 .name = "Master Playback Switch",               \
11443                 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
11444                              (SUBDEV_SPEAKER(0) << 16), \
11445         }
11446
11447 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
11448         ALC262_HIPPO_MASTER_SWITCH,
11449         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11450         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11451         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11452         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11453         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11454         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11455         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11456         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11457         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11458         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11459         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11460         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11461         { } /* end */
11462 };
11463
11464 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
11465         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11466         ALC262_HIPPO_MASTER_SWITCH,
11467         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11468         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11469         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11470         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11471         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11472         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11473         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11474         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11475         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11476         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11477         { } /* end */
11478 };
11479
11480 /* mute/unmute internal speaker according to the hp jack and mute state */
11481 static void alc262_hippo_automute(struct hda_codec *codec)
11482 {
11483         struct alc_spec *spec = codec->spec;
11484         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11485
11486         spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
11487         alc262_hippo_master_update(codec);
11488 }
11489
11490 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
11491 {
11492         if ((res >> 26) != ALC880_HP_EVENT)
11493                 return;
11494         alc262_hippo_automute(codec);
11495 }
11496
11497 static void alc262_hippo_setup(struct hda_codec *codec)
11498 {
11499         struct alc_spec *spec = codec->spec;
11500
11501         spec->autocfg.hp_pins[0] = 0x15;
11502         spec->autocfg.speaker_pins[0] = 0x14;
11503 }
11504
11505 static void alc262_hippo1_setup(struct hda_codec *codec)
11506 {
11507         struct alc_spec *spec = codec->spec;
11508
11509         spec->autocfg.hp_pins[0] = 0x1b;
11510         spec->autocfg.speaker_pins[0] = 0x14;
11511 }
11512
11513
11514 static struct snd_kcontrol_new alc262_sony_mixer[] = {
11515         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11516         ALC262_HIPPO_MASTER_SWITCH,
11517         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11518         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11519         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11520         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11521         { } /* end */
11522 };
11523
11524 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
11525         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11526         ALC262_HIPPO_MASTER_SWITCH,
11527         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11528         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11529         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11530         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11531         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11532         { } /* end */
11533 };
11534
11535 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
11536         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11537         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11538         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
11539         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
11540         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11541         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11542         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11543         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11544         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11545         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11546         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11547         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11548         { } /* end */
11549 };
11550
11551 static struct hda_verb alc262_tyan_verbs[] = {
11552         /* Headphone automute */
11553         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11554         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11555         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11556
11557         /* P11 AUX_IN, white 4-pin connector */
11558         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11559         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
11560         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
11561         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
11562
11563         {}
11564 };
11565
11566 /* unsolicited event for HP jack sensing */
11567 static void alc262_tyan_setup(struct hda_codec *codec)
11568 {
11569         struct alc_spec *spec = codec->spec;
11570
11571         spec->autocfg.hp_pins[0] = 0x1b;
11572         spec->autocfg.speaker_pins[0] = 0x15;
11573 }
11574
11575
11576 #define alc262_capture_mixer            alc882_capture_mixer
11577 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
11578
11579 /*
11580  * generic initialization of ADC, input mixers and output mixers
11581  */
11582 static struct hda_verb alc262_init_verbs[] = {
11583         /*
11584          * Unmute ADC0-2 and set the default input to mic-in
11585          */
11586         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11587         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11588         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11589         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11590         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11591         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11592
11593         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11594          * mixer widget
11595          * Note: PASD motherboards uses the Line In 2 as the input for
11596          * front panel mic (mic 2)
11597          */
11598         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11599         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11600         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11601         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11602         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11603         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11604
11605         /*
11606          * Set up output mixers (0x0c - 0x0e)
11607          */
11608         /* set vol=0 to output mixers */
11609         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11610         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11611         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11612         /* set up input amps for analog loopback */
11613         /* Amp Indices: DAC = 0, mixer = 1 */
11614         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11615         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11616         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11617         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11618         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11619         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11620
11621         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11622         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11623         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11624         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11625         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11626         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11627
11628         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11629         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11630         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11631         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11632         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11633
11634         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11635         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11636
11637         /* FIXME: use matrix-type input source selection */
11638         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11639         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11640         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11641         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11642         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11643         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11644         /* Input mixer2 */
11645         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11646         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11647         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11648         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11649         /* Input mixer3 */
11650         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11651         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11652         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11653         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11654
11655         { }
11656 };
11657
11658 static struct hda_verb alc262_eapd_verbs[] = {
11659         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11660         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11661         { }
11662 };
11663
11664 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
11665         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11666         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11667         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11668
11669         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11670         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11671         {}
11672 };
11673
11674 static struct hda_verb alc262_sony_unsol_verbs[] = {
11675         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11676         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11677         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
11678
11679         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11680         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11681         {}
11682 };
11683
11684 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
11685         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11686         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11687         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11688         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11689         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11690         { } /* end */
11691 };
11692
11693 static struct hda_verb alc262_toshiba_s06_verbs[] = {
11694         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11695         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11696         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11697         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11698         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
11699         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11700         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11701         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11702         {}
11703 };
11704
11705 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11706 {
11707         struct alc_spec *spec = codec->spec;
11708
11709         spec->autocfg.hp_pins[0] = 0x15;
11710         spec->autocfg.speaker_pins[0] = 0x14;
11711         spec->ext_mic.pin = 0x18;
11712         spec->ext_mic.mux_idx = 0;
11713         spec->int_mic.pin = 0x12;
11714         spec->int_mic.mux_idx = 9;
11715         spec->auto_mic = 1;
11716 }
11717
11718 /*
11719  * nec model
11720  *  0x15 = headphone
11721  *  0x16 = internal speaker
11722  *  0x18 = external mic
11723  */
11724
11725 static struct snd_kcontrol_new alc262_nec_mixer[] = {
11726         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11727         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11728
11729         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11730         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11731         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11732
11733         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11734         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11735         { } /* end */
11736 };
11737
11738 static struct hda_verb alc262_nec_verbs[] = {
11739         /* Unmute Speaker */
11740         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11741
11742         /* Headphone */
11743         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11744         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11745
11746         /* External mic to headphone */
11747         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11748         /* External mic to speaker */
11749         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11750         {}
11751 };
11752
11753 /*
11754  * fujitsu model
11755  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11756  *  0x1b = port replicator headphone out
11757  */
11758
11759 #define ALC_HP_EVENT    0x37
11760
11761 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11762         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11763         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11764         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11765         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11766         {}
11767 };
11768
11769 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11770         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11771         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11772         {}
11773 };
11774
11775 static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11776         /* Front Mic pin: input vref at 50% */
11777         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11778         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11779         {}
11780 };
11781
11782 static struct hda_input_mux alc262_fujitsu_capture_source = {
11783         .num_items = 3,
11784         .items = {
11785                 { "Mic", 0x0 },
11786                 { "Internal Mic", 0x1 },
11787                 { "CD", 0x4 },
11788         },
11789 };
11790
11791 static struct hda_input_mux alc262_HP_capture_source = {
11792         .num_items = 5,
11793         .items = {
11794                 { "Mic", 0x0 },
11795                 { "Front Mic", 0x1 },
11796                 { "Line", 0x2 },
11797                 { "CD", 0x4 },
11798                 { "AUX IN", 0x6 },
11799         },
11800 };
11801
11802 static struct hda_input_mux alc262_HP_D7000_capture_source = {
11803         .num_items = 4,
11804         .items = {
11805                 { "Mic", 0x0 },
11806                 { "Front Mic", 0x2 },
11807                 { "Line", 0x1 },
11808                 { "CD", 0x4 },
11809         },
11810 };
11811
11812 /* mute/unmute internal speaker according to the hp jacks and mute state */
11813 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
11814 {
11815         struct alc_spec *spec = codec->spec;
11816         unsigned int mute;
11817
11818         if (force || !spec->sense_updated) {
11819                 spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
11820                                      snd_hda_jack_detect(codec, 0x1b);
11821                 spec->sense_updated = 1;
11822         }
11823         /* unmute internal speaker only if both HPs are unplugged and
11824          * master switch is on
11825          */
11826         if (spec->jack_present)
11827                 mute = HDA_AMP_MUTE;
11828         else
11829                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11830         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11831                                  HDA_AMP_MUTE, mute);
11832 }
11833
11834 /* unsolicited event for HP jack sensing */
11835 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
11836                                        unsigned int res)
11837 {
11838         if ((res >> 26) != ALC_HP_EVENT)
11839                 return;
11840         alc262_fujitsu_automute(codec, 1);
11841 }
11842
11843 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
11844 {
11845         alc262_fujitsu_automute(codec, 1);
11846 }
11847
11848 /* bind volumes of both NID 0x0c and 0x0d */
11849 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11850         .ops = &snd_hda_bind_vol,
11851         .values = {
11852                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11853                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11854                 0
11855         },
11856 };
11857
11858 /* mute/unmute internal speaker according to the hp jack and mute state */
11859 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
11860 {
11861         struct alc_spec *spec = codec->spec;
11862         unsigned int mute;
11863
11864         if (force || !spec->sense_updated) {
11865                 spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11866                 spec->sense_updated = 1;
11867         }
11868         if (spec->jack_present) {
11869                 /* mute internal speaker */
11870                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11871                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11872                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11873                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11874         } else {
11875                 /* unmute internal speaker if necessary */
11876                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
11877                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11878                                          HDA_AMP_MUTE, mute);
11879                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11880                                          HDA_AMP_MUTE, mute);
11881         }
11882 }
11883
11884 /* unsolicited event for HP jack sensing */
11885 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
11886                                        unsigned int res)
11887 {
11888         if ((res >> 26) != ALC_HP_EVENT)
11889                 return;
11890         alc262_lenovo_3000_automute(codec, 1);
11891 }
11892
11893 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
11894                                   int dir, int idx, long *valp)
11895 {
11896         int i, change = 0;
11897
11898         for (i = 0; i < 2; i++, valp++)
11899                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
11900                                                    HDA_AMP_MUTE,
11901                                                    *valp ? 0 : HDA_AMP_MUTE);
11902         return change;
11903 }
11904
11905 /* bind hp and internal speaker mute (with plug check) */
11906 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
11907                                          struct snd_ctl_elem_value *ucontrol)
11908 {
11909         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11910         long *valp = ucontrol->value.integer.value;
11911         int change;
11912
11913         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11914         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11915         if (change)
11916                 alc262_fujitsu_automute(codec, 0);
11917         return change;
11918 }
11919
11920 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
11921         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11922         {
11923                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11924                 .name = "Master Playback Switch",
11925                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11926                 .info = snd_hda_mixer_amp_switch_info,
11927                 .get = snd_hda_mixer_amp_switch_get,
11928                 .put = alc262_fujitsu_master_sw_put,
11929                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11930         },
11931         {
11932                 .iface = NID_MAPPING,
11933                 .name = "Master Playback Switch",
11934                 .private_value = 0x1b,
11935         },
11936         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11937         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11938         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11939         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11940         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11941         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
11942         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11943         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11944         { } /* end */
11945 };
11946
11947 /* bind hp and internal speaker mute (with plug check) */
11948 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
11949                                          struct snd_ctl_elem_value *ucontrol)
11950 {
11951         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11952         long *valp = ucontrol->value.integer.value;
11953         int change;
11954
11955         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11956         if (change)
11957                 alc262_lenovo_3000_automute(codec, 0);
11958         return change;
11959 }
11960
11961 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
11962         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11963         {
11964                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11965                 .name = "Master Playback Switch",
11966                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11967                 .info = snd_hda_mixer_amp_switch_info,
11968                 .get = snd_hda_mixer_amp_switch_get,
11969                 .put = alc262_lenovo_3000_master_sw_put,
11970                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11971         },
11972         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11973         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11974         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11975         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11976         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11977         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
11978         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11979         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11980         { } /* end */
11981 };
11982
11983 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11984         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11985         ALC262_HIPPO_MASTER_SWITCH,
11986         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11987         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11988         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11989         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11990         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11991         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11992         { } /* end */
11993 };
11994
11995 /* additional init verbs for Benq laptops */
11996 static struct hda_verb alc262_EAPD_verbs[] = {
11997         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11998         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11999         {}
12000 };
12001
12002 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
12003         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12004         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12005
12006         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
12007         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
12008         {}
12009 };
12010
12011 /* Samsung Q1 Ultra Vista model setup */
12012 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
12013         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
12014         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
12015         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12016         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12017         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
12018         HDA_CODEC_VOLUME("Headphone Mic Boost Volume", 0x15, 0, HDA_INPUT),
12019         { } /* end */
12020 };
12021
12022 static struct hda_verb alc262_ultra_verbs[] = {
12023         /* output mixer */
12024         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12025         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12026         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12027         /* speaker */
12028         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12029         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12030         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12031         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12032         /* HP */
12033         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12034         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12035         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12036         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12037         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12038         /* internal mic */
12039         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12040         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12041         /* ADC, choose mic */
12042         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12043         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12044         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12045         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12046         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12047         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12048         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12049         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12050         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12051         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
12052         {}
12053 };
12054
12055 /* mute/unmute internal speaker according to the hp jack and mute state */
12056 static void alc262_ultra_automute(struct hda_codec *codec)
12057 {
12058         struct alc_spec *spec = codec->spec;
12059         unsigned int mute;
12060
12061         mute = 0;
12062         /* auto-mute only when HP is used as HP */
12063         if (!spec->cur_mux[0]) {
12064                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
12065                 if (spec->jack_present)
12066                         mute = HDA_AMP_MUTE;
12067         }
12068         /* mute/unmute internal speaker */
12069         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
12070                                  HDA_AMP_MUTE, mute);
12071         /* mute/unmute HP */
12072         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12073                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
12074 }
12075
12076 /* unsolicited event for HP jack sensing */
12077 static void alc262_ultra_unsol_event(struct hda_codec *codec,
12078                                        unsigned int res)
12079 {
12080         if ((res >> 26) != ALC880_HP_EVENT)
12081                 return;
12082         alc262_ultra_automute(codec);
12083 }
12084
12085 static struct hda_input_mux alc262_ultra_capture_source = {
12086         .num_items = 2,
12087         .items = {
12088                 { "Mic", 0x1 },
12089                 { "Headphone", 0x7 },
12090         },
12091 };
12092
12093 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
12094                                      struct snd_ctl_elem_value *ucontrol)
12095 {
12096         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12097         struct alc_spec *spec = codec->spec;
12098         int ret;
12099
12100         ret = alc_mux_enum_put(kcontrol, ucontrol);
12101         if (!ret)
12102                 return 0;
12103         /* reprogram the HP pin as mic or HP according to the input source */
12104         snd_hda_codec_write_cache(codec, 0x15, 0,
12105                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
12106                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
12107         alc262_ultra_automute(codec); /* mute/unmute HP */
12108         return ret;
12109 }
12110
12111 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
12112         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
12113         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
12114         {
12115                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12116                 .name = "Capture Source",
12117                 .info = alc_mux_enum_info,
12118                 .get = alc_mux_enum_get,
12119                 .put = alc262_ultra_mux_enum_put,
12120         },
12121         {
12122                 .iface = NID_MAPPING,
12123                 .name = "Capture Source",
12124                 .private_value = 0x15,
12125         },
12126         { } /* end */
12127 };
12128
12129 /* We use two mixers depending on the output pin; 0x16 is a mono output
12130  * and thus it's bound with a different mixer.
12131  * This function returns which mixer amp should be used.
12132  */
12133 static int alc262_check_volbit(hda_nid_t nid)
12134 {
12135         if (!nid)
12136                 return 0;
12137         else if (nid == 0x16)
12138                 return 2;
12139         else
12140                 return 1;
12141 }
12142
12143 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
12144                                   const char *pfx, int *vbits, int idx)
12145 {
12146         unsigned long val;
12147         int vbit;
12148
12149         vbit = alc262_check_volbit(nid);
12150         if (!vbit)
12151                 return 0;
12152         if (*vbits & vbit) /* a volume control for this mixer already there */
12153                 return 0;
12154         *vbits |= vbit;
12155         if (vbit == 2)
12156                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
12157         else
12158                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
12159         return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val);
12160 }
12161
12162 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
12163                                  const char *pfx, int idx)
12164 {
12165         unsigned long val;
12166
12167         if (!nid)
12168                 return 0;
12169         if (nid == 0x16)
12170                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
12171         else
12172                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
12173         return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val);
12174 }
12175
12176 /* add playback controls from the parsed DAC table */
12177 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
12178                                              const struct auto_pin_cfg *cfg)
12179 {
12180         const char *pfx;
12181         int vbits;
12182         int i, err;
12183
12184         spec->multiout.num_dacs = 1;    /* only use one dac */
12185         spec->multiout.dac_nids = spec->private_dac_nids;
12186         spec->multiout.dac_nids[0] = 2;
12187
12188         pfx = alc_get_line_out_pfx(cfg, true);
12189         if (!pfx)
12190                 pfx = "Front";
12191         for (i = 0; i < 2; i++) {
12192                 err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx, i);
12193                 if (err < 0)
12194                         return err;
12195                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12196                         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i],
12197                                                     "Speaker", i);
12198                         if (err < 0)
12199                                 return err;
12200                 }
12201                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12202                         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i],
12203                                                     "Headphone", i);
12204                         if (err < 0)
12205                                 return err;
12206                 }
12207         }
12208
12209         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
12210                 alc262_check_volbit(cfg->speaker_pins[0]) |
12211                 alc262_check_volbit(cfg->hp_pins[0]);
12212         if (vbits == 1 || vbits == 2)
12213                 pfx = "Master"; /* only one mixer is used */
12214         vbits = 0;
12215         for (i = 0; i < 2; i++) {
12216                 err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx,
12217                                              &vbits, i);
12218                 if (err < 0)
12219                         return err;
12220                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12221                         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i],
12222                                                      "Speaker", &vbits, i);
12223                         if (err < 0)
12224                                 return err;
12225                 }
12226                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12227                         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i],
12228                                                      "Headphone", &vbits, i);
12229                         if (err < 0)
12230                                 return err;
12231                 }
12232         }
12233         return 0;
12234 }
12235
12236 #define alc262_auto_create_input_ctls \
12237         alc882_auto_create_input_ctls
12238
12239 /*
12240  * generic initialization of ADC, input mixers and output mixers
12241  */
12242 static struct hda_verb alc262_volume_init_verbs[] = {
12243         /*
12244          * Unmute ADC0-2 and set the default input to mic-in
12245          */
12246         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12247         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12248         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12249         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12250         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12251         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12252
12253         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12254          * mixer widget
12255          * Note: PASD motherboards uses the Line In 2 as the input for
12256          * front panel mic (mic 2)
12257          */
12258         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12259         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12260         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12261         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12262         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12263         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12264
12265         /*
12266          * Set up output mixers (0x0c - 0x0f)
12267          */
12268         /* set vol=0 to output mixers */
12269         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12270         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12271         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12272
12273         /* set up input amps for analog loopback */
12274         /* Amp Indices: DAC = 0, mixer = 1 */
12275         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12276         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12277         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12278         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12279         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12280         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12281
12282         /* FIXME: use matrix-type input source selection */
12283         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12284         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12285         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12286         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12287         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12288         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12289         /* Input mixer2 */
12290         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12291         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12292         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12293         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12294         /* Input mixer3 */
12295         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12296         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12297         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12298         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12299
12300         { }
12301 };
12302
12303 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
12304         /*
12305          * Unmute ADC0-2 and set the default input to mic-in
12306          */
12307         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12308         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12309         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12310         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12311         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12312         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12313
12314         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12315          * mixer widget
12316          * Note: PASD motherboards uses the Line In 2 as the input for
12317          * front panel mic (mic 2)
12318          */
12319         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12320         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12321         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12322         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12323         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12324         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12325         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12326         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12327
12328         /*
12329          * Set up output mixers (0x0c - 0x0e)
12330          */
12331         /* set vol=0 to output mixers */
12332         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12333         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12334         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12335
12336         /* set up input amps for analog loopback */
12337         /* Amp Indices: DAC = 0, mixer = 1 */
12338         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12339         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12340         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12341         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12342         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12343         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12344
12345         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12346         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12347         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12348
12349         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12350         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12351
12352         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12353         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12354
12355         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12356         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12357         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12358         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12359         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12360
12361         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12362         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12363         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12364         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12365         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12366         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12367
12368
12369         /* FIXME: use matrix-type input source selection */
12370         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
12371         /* Input mixer1: only unmute Mic */
12372         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12373         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12374         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12375         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12376         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12377         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12378         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12379         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12380         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12381         /* Input mixer2 */
12382         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12383         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12384         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12385         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12386         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12387         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12388         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12389         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12390         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12391         /* Input mixer3 */
12392         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12393         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12394         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12395         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12396         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12397         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12398         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12399         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12400         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12401
12402         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12403
12404         { }
12405 };
12406
12407 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
12408         /*
12409          * Unmute ADC0-2 and set the default input to mic-in
12410          */
12411         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12412         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12413         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12414         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12415         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12416         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12417
12418         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12419          * mixer widget
12420          * Note: PASD motherboards uses the Line In 2 as the input for front
12421          * panel mic (mic 2)
12422          */
12423         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12424         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12425         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12426         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12427         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12428         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12429         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12430         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12431         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12432         /*
12433          * Set up output mixers (0x0c - 0x0e)
12434          */
12435         /* set vol=0 to output mixers */
12436         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12437         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12438         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12439
12440         /* set up input amps for analog loopback */
12441         /* Amp Indices: DAC = 0, mixer = 1 */
12442         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12443         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12444         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12445         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12446         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12447         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12448
12449
12450         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
12451         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
12452         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
12453         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
12454         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12455         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
12456         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
12457
12458         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12459         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12460
12461         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12462         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12463
12464         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
12465         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12466         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12467         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
12468         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12469         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12470
12471         /* FIXME: use matrix-type input source selection */
12472         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12473         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12474         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
12475         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
12476         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
12477         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
12478         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
12479         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
12480         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
12481         /* Input mixer2 */
12482         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12483         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12484         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12485         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12486         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12487         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12488         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12489         /* Input mixer3 */
12490         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12491         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12492         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12493         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12494         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12495         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12496         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12497
12498         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12499
12500         { }
12501 };
12502
12503 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
12504
12505         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
12506         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12507         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
12508
12509         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
12510         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12511         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12512         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12513
12514         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
12515         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12516         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12517         {}
12518 };
12519
12520 /*
12521  * Pin config fixes
12522  */
12523 enum {
12524         PINFIX_FSC_H270,
12525 };
12526
12527 static const struct alc_fixup alc262_fixups[] = {
12528         [PINFIX_FSC_H270] = {
12529                 .type = ALC_FIXUP_PINS,
12530                 .v.pins = (const struct alc_pincfg[]) {
12531                         { 0x14, 0x99130110 }, /* speaker */
12532                         { 0x15, 0x0221142f }, /* front HP */
12533                         { 0x1b, 0x0121141f }, /* rear HP */
12534                         { }
12535                 }
12536         },
12537 };
12538
12539 static struct snd_pci_quirk alc262_fixup_tbl[] = {
12540         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
12541         {}
12542 };
12543
12544
12545 #ifdef CONFIG_SND_HDA_POWER_SAVE
12546 #define alc262_loopbacks        alc880_loopbacks
12547 #endif
12548
12549 /* pcm configuration: identical with ALC880 */
12550 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
12551 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
12552 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
12553 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
12554
12555 /*
12556  * BIOS auto configuration
12557  */
12558 static int alc262_parse_auto_config(struct hda_codec *codec)
12559 {
12560         struct alc_spec *spec = codec->spec;
12561         int err;
12562         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
12563
12564         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12565                                            alc262_ignore);
12566         if (err < 0)
12567                 return err;
12568         if (!spec->autocfg.line_outs) {
12569                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12570                         spec->multiout.max_channels = 2;
12571                         spec->no_analog = 1;
12572                         goto dig_only;
12573                 }
12574                 return 0; /* can't find valid BIOS pin config */
12575         }
12576         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
12577         if (err < 0)
12578                 return err;
12579         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
12580         if (err < 0)
12581                 return err;
12582
12583         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12584
12585  dig_only:
12586         alc_auto_parse_digital(codec);
12587
12588         if (spec->kctls.list)
12589                 add_mixer(spec, spec->kctls.list);
12590
12591         add_verb(spec, alc262_volume_init_verbs);
12592         spec->num_mux_defs = 1;
12593         spec->input_mux = &spec->private_imux[0];
12594
12595         err = alc_auto_add_mic_boost(codec);
12596         if (err < 0)
12597                 return err;
12598
12599         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
12600
12601         return 1;
12602 }
12603
12604 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
12605 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
12606 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
12607 #define alc262_auto_init_input_src      alc882_auto_init_input_src
12608
12609
12610 /* init callback for auto-configuration model -- overriding the default init */
12611 static void alc262_auto_init(struct hda_codec *codec)
12612 {
12613         struct alc_spec *spec = codec->spec;
12614         alc262_auto_init_multi_out(codec);
12615         alc262_auto_init_hp_out(codec);
12616         alc262_auto_init_analog_input(codec);
12617         alc262_auto_init_input_src(codec);
12618         alc_auto_init_digital(codec);
12619         if (spec->unsol_event)
12620                 alc_inithook(codec);
12621 }
12622
12623 /*
12624  * configuration and preset
12625  */
12626 static const char * const alc262_models[ALC262_MODEL_LAST] = {
12627         [ALC262_BASIC]          = "basic",
12628         [ALC262_HIPPO]          = "hippo",
12629         [ALC262_HIPPO_1]        = "hippo_1",
12630         [ALC262_FUJITSU]        = "fujitsu",
12631         [ALC262_HP_BPC]         = "hp-bpc",
12632         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
12633         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
12634         [ALC262_HP_RP5700]      = "hp-rp5700",
12635         [ALC262_BENQ_ED8]       = "benq",
12636         [ALC262_BENQ_T31]       = "benq-t31",
12637         [ALC262_SONY_ASSAMD]    = "sony-assamd",
12638         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
12639         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
12640         [ALC262_ULTRA]          = "ultra",
12641         [ALC262_LENOVO_3000]    = "lenovo-3000",
12642         [ALC262_NEC]            = "nec",
12643         [ALC262_TYAN]           = "tyan",
12644         [ALC262_AUTO]           = "auto",
12645 };
12646
12647 static struct snd_pci_quirk alc262_cfg_tbl[] = {
12648         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
12649         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
12650         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
12651                            ALC262_HP_BPC),
12652         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
12653                            ALC262_HP_BPC),
12654         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1500, "HP z series",
12655                            ALC262_HP_BPC),
12656         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
12657                            ALC262_HP_BPC),
12658         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
12659         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
12660         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
12661         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
12662         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
12663         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
12664         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
12665         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
12666         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
12667         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
12668         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
12669         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
12670                       ALC262_HP_TC_T5735),
12671         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
12672         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12673         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
12674         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12675         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
12676         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
12677         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
12678         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
12679 #if 0 /* disable the quirk since model=auto works better in recent versions */
12680         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
12681                            ALC262_SONY_ASSAMD),
12682 #endif
12683         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
12684                       ALC262_TOSHIBA_RX1),
12685         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
12686         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
12687         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
12688         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
12689         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
12690                            ALC262_ULTRA),
12691         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
12692         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
12693         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
12694         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
12695         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
12696         {}
12697 };
12698
12699 static struct alc_config_preset alc262_presets[] = {
12700         [ALC262_BASIC] = {
12701                 .mixers = { alc262_base_mixer },
12702                 .init_verbs = { alc262_init_verbs },
12703                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12704                 .dac_nids = alc262_dac_nids,
12705                 .hp_nid = 0x03,
12706                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12707                 .channel_mode = alc262_modes,
12708                 .input_mux = &alc262_capture_source,
12709         },
12710         [ALC262_HIPPO] = {
12711                 .mixers = { alc262_hippo_mixer },
12712                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
12713                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12714                 .dac_nids = alc262_dac_nids,
12715                 .hp_nid = 0x03,
12716                 .dig_out_nid = ALC262_DIGOUT_NID,
12717                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12718                 .channel_mode = alc262_modes,
12719                 .input_mux = &alc262_capture_source,
12720                 .unsol_event = alc262_hippo_unsol_event,
12721                 .setup = alc262_hippo_setup,
12722                 .init_hook = alc262_hippo_automute,
12723         },
12724         [ALC262_HIPPO_1] = {
12725                 .mixers = { alc262_hippo1_mixer },
12726                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
12727                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12728                 .dac_nids = alc262_dac_nids,
12729                 .hp_nid = 0x02,
12730                 .dig_out_nid = ALC262_DIGOUT_NID,
12731                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12732                 .channel_mode = alc262_modes,
12733                 .input_mux = &alc262_capture_source,
12734                 .unsol_event = alc262_hippo_unsol_event,
12735                 .setup = alc262_hippo1_setup,
12736                 .init_hook = alc262_hippo_automute,
12737         },
12738         [ALC262_FUJITSU] = {
12739                 .mixers = { alc262_fujitsu_mixer },
12740                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12741                                 alc262_fujitsu_unsol_verbs },
12742                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12743                 .dac_nids = alc262_dac_nids,
12744                 .hp_nid = 0x03,
12745                 .dig_out_nid = ALC262_DIGOUT_NID,
12746                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12747                 .channel_mode = alc262_modes,
12748                 .input_mux = &alc262_fujitsu_capture_source,
12749                 .unsol_event = alc262_fujitsu_unsol_event,
12750                 .init_hook = alc262_fujitsu_init_hook,
12751         },
12752         [ALC262_HP_BPC] = {
12753                 .mixers = { alc262_HP_BPC_mixer },
12754                 .init_verbs = { alc262_HP_BPC_init_verbs },
12755                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12756                 .dac_nids = alc262_dac_nids,
12757                 .hp_nid = 0x03,
12758                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12759                 .channel_mode = alc262_modes,
12760                 .input_mux = &alc262_HP_capture_source,
12761                 .unsol_event = alc262_hp_bpc_unsol_event,
12762                 .init_hook = alc262_hp_bpc_automute,
12763         },
12764         [ALC262_HP_BPC_D7000_WF] = {
12765                 .mixers = { alc262_HP_BPC_WildWest_mixer },
12766                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12767                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12768                 .dac_nids = alc262_dac_nids,
12769                 .hp_nid = 0x03,
12770                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12771                 .channel_mode = alc262_modes,
12772                 .input_mux = &alc262_HP_D7000_capture_source,
12773                 .unsol_event = alc262_hp_wildwest_unsol_event,
12774                 .init_hook = alc262_hp_wildwest_automute,
12775         },
12776         [ALC262_HP_BPC_D7000_WL] = {
12777                 .mixers = { alc262_HP_BPC_WildWest_mixer,
12778                             alc262_HP_BPC_WildWest_option_mixer },
12779                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12780                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12781                 .dac_nids = alc262_dac_nids,
12782                 .hp_nid = 0x03,
12783                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12784                 .channel_mode = alc262_modes,
12785                 .input_mux = &alc262_HP_D7000_capture_source,
12786                 .unsol_event = alc262_hp_wildwest_unsol_event,
12787                 .init_hook = alc262_hp_wildwest_automute,
12788         },
12789         [ALC262_HP_TC_T5735] = {
12790                 .mixers = { alc262_hp_t5735_mixer },
12791                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12792                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12793                 .dac_nids = alc262_dac_nids,
12794                 .hp_nid = 0x03,
12795                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12796                 .channel_mode = alc262_modes,
12797                 .input_mux = &alc262_capture_source,
12798                 .unsol_event = alc_sku_unsol_event,
12799                 .setup = alc262_hp_t5735_setup,
12800                 .init_hook = alc_inithook,
12801         },
12802         [ALC262_HP_RP5700] = {
12803                 .mixers = { alc262_hp_rp5700_mixer },
12804                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12805                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12806                 .dac_nids = alc262_dac_nids,
12807                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12808                 .channel_mode = alc262_modes,
12809                 .input_mux = &alc262_hp_rp5700_capture_source,
12810         },
12811         [ALC262_BENQ_ED8] = {
12812                 .mixers = { alc262_base_mixer },
12813                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12814                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12815                 .dac_nids = alc262_dac_nids,
12816                 .hp_nid = 0x03,
12817                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12818                 .channel_mode = alc262_modes,
12819                 .input_mux = &alc262_capture_source,
12820         },
12821         [ALC262_SONY_ASSAMD] = {
12822                 .mixers = { alc262_sony_mixer },
12823                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12824                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12825                 .dac_nids = alc262_dac_nids,
12826                 .hp_nid = 0x02,
12827                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12828                 .channel_mode = alc262_modes,
12829                 .input_mux = &alc262_capture_source,
12830                 .unsol_event = alc262_hippo_unsol_event,
12831                 .setup = alc262_hippo_setup,
12832                 .init_hook = alc262_hippo_automute,
12833         },
12834         [ALC262_BENQ_T31] = {
12835                 .mixers = { alc262_benq_t31_mixer },
12836                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12837                                 alc_hp15_unsol_verbs },
12838                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12839                 .dac_nids = alc262_dac_nids,
12840                 .hp_nid = 0x03,
12841                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12842                 .channel_mode = alc262_modes,
12843                 .input_mux = &alc262_capture_source,
12844                 .unsol_event = alc262_hippo_unsol_event,
12845                 .setup = alc262_hippo_setup,
12846                 .init_hook = alc262_hippo_automute,
12847         },
12848         [ALC262_ULTRA] = {
12849                 .mixers = { alc262_ultra_mixer },
12850                 .cap_mixer = alc262_ultra_capture_mixer,
12851                 .init_verbs = { alc262_ultra_verbs },
12852                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12853                 .dac_nids = alc262_dac_nids,
12854                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12855                 .channel_mode = alc262_modes,
12856                 .input_mux = &alc262_ultra_capture_source,
12857                 .adc_nids = alc262_adc_nids, /* ADC0 */
12858                 .capsrc_nids = alc262_capsrc_nids,
12859                 .num_adc_nids = 1, /* single ADC */
12860                 .unsol_event = alc262_ultra_unsol_event,
12861                 .init_hook = alc262_ultra_automute,
12862         },
12863         [ALC262_LENOVO_3000] = {
12864                 .mixers = { alc262_lenovo_3000_mixer },
12865                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12866                                 alc262_lenovo_3000_unsol_verbs,
12867                                 alc262_lenovo_3000_init_verbs },
12868                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12869                 .dac_nids = alc262_dac_nids,
12870                 .hp_nid = 0x03,
12871                 .dig_out_nid = ALC262_DIGOUT_NID,
12872                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12873                 .channel_mode = alc262_modes,
12874                 .input_mux = &alc262_fujitsu_capture_source,
12875                 .unsol_event = alc262_lenovo_3000_unsol_event,
12876         },
12877         [ALC262_NEC] = {
12878                 .mixers = { alc262_nec_mixer },
12879                 .init_verbs = { alc262_nec_verbs },
12880                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12881                 .dac_nids = alc262_dac_nids,
12882                 .hp_nid = 0x03,
12883                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12884                 .channel_mode = alc262_modes,
12885                 .input_mux = &alc262_capture_source,
12886         },
12887         [ALC262_TOSHIBA_S06] = {
12888                 .mixers = { alc262_toshiba_s06_mixer },
12889                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12890                                                         alc262_eapd_verbs },
12891                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12892                 .capsrc_nids = alc262_dmic_capsrc_nids,
12893                 .dac_nids = alc262_dac_nids,
12894                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12895                 .num_adc_nids = 1, /* single ADC */
12896                 .dig_out_nid = ALC262_DIGOUT_NID,
12897                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12898                 .channel_mode = alc262_modes,
12899                 .unsol_event = alc_sku_unsol_event,
12900                 .setup = alc262_toshiba_s06_setup,
12901                 .init_hook = alc_inithook,
12902         },
12903         [ALC262_TOSHIBA_RX1] = {
12904                 .mixers = { alc262_toshiba_rx1_mixer },
12905                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12906                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12907                 .dac_nids = alc262_dac_nids,
12908                 .hp_nid = 0x03,
12909                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12910                 .channel_mode = alc262_modes,
12911                 .input_mux = &alc262_capture_source,
12912                 .unsol_event = alc262_hippo_unsol_event,
12913                 .setup = alc262_hippo_setup,
12914                 .init_hook = alc262_hippo_automute,
12915         },
12916         [ALC262_TYAN] = {
12917                 .mixers = { alc262_tyan_mixer },
12918                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
12919                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12920                 .dac_nids = alc262_dac_nids,
12921                 .hp_nid = 0x02,
12922                 .dig_out_nid = ALC262_DIGOUT_NID,
12923                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12924                 .channel_mode = alc262_modes,
12925                 .input_mux = &alc262_capture_source,
12926                 .unsol_event = alc_automute_amp_unsol_event,
12927                 .setup = alc262_tyan_setup,
12928                 .init_hook = alc_automute_amp,
12929         },
12930 };
12931
12932 static int patch_alc262(struct hda_codec *codec)
12933 {
12934         struct alc_spec *spec;
12935         int board_config;
12936         int err;
12937
12938         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12939         if (spec == NULL)
12940                 return -ENOMEM;
12941
12942         codec->spec = spec;
12943 #if 0
12944         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
12945          * under-run
12946          */
12947         {
12948         int tmp;
12949         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12950         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
12951         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12952         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
12953         }
12954 #endif
12955         alc_auto_parse_customize_define(codec);
12956
12957         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
12958
12959         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
12960                                                   alc262_models,
12961                                                   alc262_cfg_tbl);
12962
12963         if (board_config < 0) {
12964                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12965                        codec->chip_name);
12966                 board_config = ALC262_AUTO;
12967         }
12968
12969         if (board_config == ALC262_AUTO) {
12970                 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
12971                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
12972         }
12973
12974         if (board_config == ALC262_AUTO) {
12975                 /* automatic parse from the BIOS config */
12976                 err = alc262_parse_auto_config(codec);
12977                 if (err < 0) {
12978                         alc_free(codec);
12979                         return err;
12980                 } else if (!err) {
12981                         printk(KERN_INFO
12982                                "hda_codec: Cannot set up configuration "
12983                                "from BIOS.  Using base mode...\n");
12984                         board_config = ALC262_BASIC;
12985                 }
12986         }
12987
12988         if (!spec->no_analog && has_cdefine_beep(codec)) {
12989                 err = snd_hda_attach_beep_device(codec, 0x1);
12990                 if (err < 0) {
12991                         alc_free(codec);
12992                         return err;
12993                 }
12994         }
12995
12996         if (board_config != ALC262_AUTO)
12997                 setup_preset(codec, &alc262_presets[board_config]);
12998
12999         spec->stream_analog_playback = &alc262_pcm_analog_playback;
13000         spec->stream_analog_capture = &alc262_pcm_analog_capture;
13001
13002         spec->stream_digital_playback = &alc262_pcm_digital_playback;
13003         spec->stream_digital_capture = &alc262_pcm_digital_capture;
13004
13005         if (!spec->adc_nids && spec->input_mux) {
13006                 int i;
13007                 /* check whether the digital-mic has to be supported */
13008                 for (i = 0; i < spec->input_mux->num_items; i++) {
13009                         if (spec->input_mux->items[i].index >= 9)
13010                                 break;
13011                 }
13012                 if (i < spec->input_mux->num_items) {
13013                         /* use only ADC0 */
13014                         spec->adc_nids = alc262_dmic_adc_nids;
13015                         spec->num_adc_nids = 1;
13016                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
13017                 } else {
13018                         /* all analog inputs */
13019                         /* check whether NID 0x07 is valid */
13020                         unsigned int wcap = get_wcaps(codec, 0x07);
13021
13022                         /* get type */
13023                         wcap = get_wcaps_type(wcap);
13024                         if (wcap != AC_WID_AUD_IN) {
13025                                 spec->adc_nids = alc262_adc_nids_alt;
13026                                 spec->num_adc_nids =
13027                                         ARRAY_SIZE(alc262_adc_nids_alt);
13028                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
13029                         } else {
13030                                 spec->adc_nids = alc262_adc_nids;
13031                                 spec->num_adc_nids =
13032                                         ARRAY_SIZE(alc262_adc_nids);
13033                                 spec->capsrc_nids = alc262_capsrc_nids;
13034                         }
13035                 }
13036         }
13037         if (!spec->cap_mixer && !spec->no_analog)
13038                 set_capture_mixer(codec);
13039         if (!spec->no_analog && has_cdefine_beep(codec))
13040                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
13041
13042         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
13043
13044         spec->vmaster_nid = 0x0c;
13045
13046         codec->patch_ops = alc_patch_ops;
13047         if (board_config == ALC262_AUTO)
13048                 spec->init_hook = alc262_auto_init;
13049
13050         alc_init_jacks(codec);
13051 #ifdef CONFIG_SND_HDA_POWER_SAVE
13052         if (!spec->loopback.amplist)
13053                 spec->loopback.amplist = alc262_loopbacks;
13054 #endif
13055
13056         return 0;
13057 }
13058
13059 /*
13060  *  ALC268 channel source setting (2 channel)
13061  */
13062 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
13063 #define alc268_modes            alc260_modes
13064
13065 static hda_nid_t alc268_dac_nids[2] = {
13066         /* front, hp */
13067         0x02, 0x03
13068 };
13069
13070 static hda_nid_t alc268_adc_nids[2] = {
13071         /* ADC0-1 */
13072         0x08, 0x07
13073 };
13074
13075 static hda_nid_t alc268_adc_nids_alt[1] = {
13076         /* ADC0 */
13077         0x08
13078 };
13079
13080 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
13081
13082 static struct snd_kcontrol_new alc268_base_mixer[] = {
13083         /* output mixer control */
13084         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13085         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13086         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13087         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13088         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13089         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
13090         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13091         { }
13092 };
13093
13094 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
13095         /* output mixer control */
13096         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13097         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13098         ALC262_HIPPO_MASTER_SWITCH,
13099         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13100         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
13101         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13102         { }
13103 };
13104
13105 /* bind Beep switches of both NID 0x0f and 0x10 */
13106 static struct hda_bind_ctls alc268_bind_beep_sw = {
13107         .ops = &snd_hda_bind_sw,
13108         .values = {
13109                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
13110                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
13111                 0
13112         },
13113 };
13114
13115 static struct snd_kcontrol_new alc268_beep_mixer[] = {
13116         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
13117         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
13118         { }
13119 };
13120
13121 static struct hda_verb alc268_eapd_verbs[] = {
13122         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13123         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13124         { }
13125 };
13126
13127 /* Toshiba specific */
13128 static struct hda_verb alc268_toshiba_verbs[] = {
13129         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13130         { } /* end */
13131 };
13132
13133 /* Acer specific */
13134 /* bind volumes of both NID 0x02 and 0x03 */
13135 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
13136         .ops = &snd_hda_bind_vol,
13137         .values = {
13138                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
13139                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
13140                 0
13141         },
13142 };
13143
13144 /* mute/unmute internal speaker according to the hp jack and mute state */
13145 static void alc268_acer_automute(struct hda_codec *codec, int force)
13146 {
13147         struct alc_spec *spec = codec->spec;
13148         unsigned int mute;
13149
13150         if (force || !spec->sense_updated) {
13151                 spec->jack_present = snd_hda_jack_detect(codec, 0x14);
13152                 spec->sense_updated = 1;
13153         }
13154         if (spec->jack_present)
13155                 mute = HDA_AMP_MUTE; /* mute internal speaker */
13156         else /* unmute internal speaker if necessary */
13157                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
13158         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
13159                                  HDA_AMP_MUTE, mute);
13160 }
13161
13162
13163 /* bind hp and internal speaker mute (with plug check) */
13164 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
13165                                      struct snd_ctl_elem_value *ucontrol)
13166 {
13167         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
13168         long *valp = ucontrol->value.integer.value;
13169         int change;
13170
13171         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
13172         if (change)
13173                 alc268_acer_automute(codec, 0);
13174         return change;
13175 }
13176
13177 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
13178         /* output mixer control */
13179         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13180         {
13181                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13182                 .name = "Master Playback Switch",
13183                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13184                 .info = snd_hda_mixer_amp_switch_info,
13185                 .get = snd_hda_mixer_amp_switch_get,
13186                 .put = alc268_acer_master_sw_put,
13187                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13188         },
13189         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
13190         { }
13191 };
13192
13193 static struct snd_kcontrol_new alc268_acer_mixer[] = {
13194         /* output mixer control */
13195         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13196         {
13197                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13198                 .name = "Master Playback Switch",
13199                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13200                 .info = snd_hda_mixer_amp_switch_info,
13201                 .get = snd_hda_mixer_amp_switch_get,
13202                 .put = alc268_acer_master_sw_put,
13203                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13204         },
13205         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13206         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13207         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13208         { }
13209 };
13210
13211 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
13212         /* output mixer control */
13213         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13214         {
13215                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13216                 .name = "Master Playback Switch",
13217                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13218                 .info = snd_hda_mixer_amp_switch_info,
13219                 .get = snd_hda_mixer_amp_switch_get,
13220                 .put = alc268_acer_master_sw_put,
13221                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13222         },
13223         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13224         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13225         { }
13226 };
13227
13228 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
13229         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13230         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13231         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13232         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13233         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
13234         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
13235         { }
13236 };
13237
13238 static struct hda_verb alc268_acer_verbs[] = {
13239         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
13240         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13241         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13242         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13243         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13244         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13245         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13246         { }
13247 };
13248
13249 /* unsolicited event for HP jack sensing */
13250 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
13251 #define alc268_toshiba_setup            alc262_hippo_setup
13252 #define alc268_toshiba_automute         alc262_hippo_automute
13253
13254 static void alc268_acer_unsol_event(struct hda_codec *codec,
13255                                        unsigned int res)
13256 {
13257         if ((res >> 26) != ALC880_HP_EVENT)
13258                 return;
13259         alc268_acer_automute(codec, 1);
13260 }
13261
13262 static void alc268_acer_init_hook(struct hda_codec *codec)
13263 {
13264         alc268_acer_automute(codec, 1);
13265 }
13266
13267 /* toggle speaker-output according to the hp-jack state */
13268 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
13269 {
13270         unsigned int present;
13271         unsigned char bits;
13272
13273         present = snd_hda_jack_detect(codec, 0x15);
13274         bits = present ? HDA_AMP_MUTE : 0;
13275         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
13276                                  HDA_AMP_MUTE, bits);
13277         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
13278                                  HDA_AMP_MUTE, bits);
13279 }
13280
13281 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
13282                                     unsigned int res)
13283 {
13284         switch (res >> 26) {
13285         case ALC880_HP_EVENT:
13286                 alc268_aspire_one_speaker_automute(codec);
13287                 break;
13288         case ALC880_MIC_EVENT:
13289                 alc_mic_automute(codec);
13290                 break;
13291         }
13292 }
13293
13294 static void alc268_acer_lc_setup(struct hda_codec *codec)
13295 {
13296         struct alc_spec *spec = codec->spec;
13297         spec->ext_mic.pin = 0x18;
13298         spec->ext_mic.mux_idx = 0;
13299         spec->int_mic.pin = 0x12;
13300         spec->int_mic.mux_idx = 6;
13301         spec->auto_mic = 1;
13302 }
13303
13304 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
13305 {
13306         alc268_aspire_one_speaker_automute(codec);
13307         alc_mic_automute(codec);
13308 }
13309
13310 static struct snd_kcontrol_new alc268_dell_mixer[] = {
13311         /* output mixer control */
13312         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13313         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13314         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13315         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13316         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13317         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13318         { }
13319 };
13320
13321 static struct hda_verb alc268_dell_verbs[] = {
13322         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13323         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13324         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13325         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13326         { }
13327 };
13328
13329 /* mute/unmute internal speaker according to the hp jack and mute state */
13330 static void alc268_dell_setup(struct hda_codec *codec)
13331 {
13332         struct alc_spec *spec = codec->spec;
13333
13334         spec->autocfg.hp_pins[0] = 0x15;
13335         spec->autocfg.speaker_pins[0] = 0x14;
13336         spec->ext_mic.pin = 0x18;
13337         spec->ext_mic.mux_idx = 0;
13338         spec->int_mic.pin = 0x19;
13339         spec->int_mic.mux_idx = 1;
13340         spec->auto_mic = 1;
13341 }
13342
13343 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
13344         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13345         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13346         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13347         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13348         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13349         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
13350         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13351         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13352         { }
13353 };
13354
13355 static struct hda_verb alc267_quanta_il1_verbs[] = {
13356         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13357         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13358         { }
13359 };
13360
13361 static void alc267_quanta_il1_setup(struct hda_codec *codec)
13362 {
13363         struct alc_spec *spec = codec->spec;
13364         spec->autocfg.hp_pins[0] = 0x15;
13365         spec->autocfg.speaker_pins[0] = 0x14;
13366         spec->ext_mic.pin = 0x18;
13367         spec->ext_mic.mux_idx = 0;
13368         spec->int_mic.pin = 0x19;
13369         spec->int_mic.mux_idx = 1;
13370         spec->auto_mic = 1;
13371 }
13372
13373 /*
13374  * generic initialization of ADC, input mixers and output mixers
13375  */
13376 static struct hda_verb alc268_base_init_verbs[] = {
13377         /* Unmute DAC0-1 and set vol = 0 */
13378         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13379         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13380
13381         /*
13382          * Set up output mixers (0x0c - 0x0e)
13383          */
13384         /* set vol=0 to output mixers */
13385         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13386         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
13387
13388         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13389         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13390
13391         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13392         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
13393         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13394         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13395         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13396         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13397         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13398         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13399
13400         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13401         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13402         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13403         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13404         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13405
13406         /* set PCBEEP vol = 0, mute connections */
13407         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13408         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13409         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13410
13411         /* Unmute Selector 23h,24h and set the default input to mic-in */
13412
13413         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13414         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13415         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
13416         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13417
13418         { }
13419 };
13420
13421 /*
13422  * generic initialization of ADC, input mixers and output mixers
13423  */
13424 static struct hda_verb alc268_volume_init_verbs[] = {
13425         /* set output DAC */
13426         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13427         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13428
13429         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13430         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13431         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13432         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13433         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13434
13435         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13436         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13437         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13438
13439         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13440         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13441
13442         /* set PCBEEP vol = 0, mute connections */
13443         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13444         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13445         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13446
13447         { }
13448 };
13449
13450 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
13451         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13452         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13453         { } /* end */
13454 };
13455
13456 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
13457         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13458         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13459         _DEFINE_CAPSRC(1),
13460         { } /* end */
13461 };
13462
13463 static struct snd_kcontrol_new alc268_capture_mixer[] = {
13464         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13465         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13466         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
13467         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
13468         _DEFINE_CAPSRC(2),
13469         { } /* end */
13470 };
13471
13472 static struct hda_input_mux alc268_capture_source = {
13473         .num_items = 4,
13474         .items = {
13475                 { "Mic", 0x0 },
13476                 { "Front Mic", 0x1 },
13477                 { "Line", 0x2 },
13478                 { "CD", 0x3 },
13479         },
13480 };
13481
13482 static struct hda_input_mux alc268_acer_capture_source = {
13483         .num_items = 3,
13484         .items = {
13485                 { "Mic", 0x0 },
13486                 { "Internal Mic", 0x1 },
13487                 { "Line", 0x2 },
13488         },
13489 };
13490
13491 static struct hda_input_mux alc268_acer_dmic_capture_source = {
13492         .num_items = 3,
13493         .items = {
13494                 { "Mic", 0x0 },
13495                 { "Internal Mic", 0x6 },
13496                 { "Line", 0x2 },
13497         },
13498 };
13499
13500 #ifdef CONFIG_SND_DEBUG
13501 static struct snd_kcontrol_new alc268_test_mixer[] = {
13502         /* Volume widgets */
13503         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13504         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13505         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13506         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
13507         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
13508         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
13509         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
13510         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
13511         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
13512         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
13513         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
13514         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
13515         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
13516         /* The below appears problematic on some hardwares */
13517         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
13518         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13519         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
13520         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
13521         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
13522
13523         /* Modes for retasking pin widgets */
13524         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
13525         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
13526         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
13527         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
13528
13529         /* Controls for GPIO pins, assuming they are configured as outputs */
13530         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
13531         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
13532         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
13533         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
13534
13535         /* Switches to allow the digital SPDIF output pin to be enabled.
13536          * The ALC268 does not have an SPDIF input.
13537          */
13538         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
13539
13540         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
13541          * this output to turn on an external amplifier.
13542          */
13543         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
13544         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
13545
13546         { } /* end */
13547 };
13548 #endif
13549
13550 /* create input playback/capture controls for the given pin */
13551 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
13552                                     const char *ctlname, int idx)
13553 {
13554         hda_nid_t dac;
13555         int err;
13556
13557         switch (nid) {
13558         case 0x14:
13559         case 0x16:
13560                 dac = 0x02;
13561                 break;
13562         case 0x15:
13563         case 0x1a: /* ALC259/269 only */
13564         case 0x1b: /* ALC259/269 only */
13565         case 0x21: /* ALC269vb has this pin, too */
13566                 dac = 0x03;
13567                 break;
13568         default:
13569                 snd_printd(KERN_WARNING "hda_codec: "
13570                            "ignoring pin 0x%x as unknown\n", nid);
13571                 return 0;
13572         }
13573         if (spec->multiout.dac_nids[0] != dac &&
13574             spec->multiout.dac_nids[1] != dac) {
13575                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
13576                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
13577                                                       HDA_OUTPUT));
13578                 if (err < 0)
13579                         return err;
13580                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
13581         }
13582
13583         if (nid != 0x16)
13584                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13585                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
13586         else /* mono */
13587                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13588                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
13589         if (err < 0)
13590                 return err;
13591         return 0;
13592 }
13593
13594 /* add playback controls from the parsed DAC table */
13595 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
13596                                              const struct auto_pin_cfg *cfg)
13597 {
13598         hda_nid_t nid;
13599         int err;
13600
13601         spec->multiout.dac_nids = spec->private_dac_nids;
13602
13603         nid = cfg->line_out_pins[0];
13604         if (nid) {
13605                 const char *name;
13606                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
13607                         name = "Speaker";
13608                 else
13609                         name = "Front";
13610                 err = alc268_new_analog_output(spec, nid, name, 0);
13611                 if (err < 0)
13612                         return err;
13613         }
13614
13615         nid = cfg->speaker_pins[0];
13616         if (nid == 0x1d) {
13617                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
13618                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
13619                 if (err < 0)
13620                         return err;
13621         } else if (nid) {
13622                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
13623                 if (err < 0)
13624                         return err;
13625         }
13626         nid = cfg->hp_pins[0];
13627         if (nid) {
13628                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
13629                 if (err < 0)
13630                         return err;
13631         }
13632
13633         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
13634         if (nid == 0x16) {
13635                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
13636                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
13637                 if (err < 0)
13638                         return err;
13639         }
13640         return 0;
13641 }
13642
13643 /* create playback/capture controls for input pins */
13644 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
13645                                                 const struct auto_pin_cfg *cfg)
13646 {
13647         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
13648 }
13649
13650 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
13651                                               hda_nid_t nid, int pin_type)
13652 {
13653         int idx;
13654
13655         alc_set_pin_output(codec, nid, pin_type);
13656         if (nid == 0x14 || nid == 0x16)
13657                 idx = 0;
13658         else
13659                 idx = 1;
13660         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
13661 }
13662
13663 static void alc268_auto_init_multi_out(struct hda_codec *codec)
13664 {
13665         struct alc_spec *spec = codec->spec;
13666         int i;
13667
13668         for (i = 0; i < spec->autocfg.line_outs; i++) {
13669                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13670                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13671                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
13672         }
13673 }
13674
13675 static void alc268_auto_init_hp_out(struct hda_codec *codec)
13676 {
13677         struct alc_spec *spec = codec->spec;
13678         hda_nid_t pin;
13679         int i;
13680
13681         for (i = 0; i < spec->autocfg.hp_outs; i++) {
13682                 pin = spec->autocfg.hp_pins[i];
13683                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
13684         }
13685         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
13686                 pin = spec->autocfg.speaker_pins[i];
13687                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
13688         }
13689         if (spec->autocfg.mono_out_pin)
13690                 snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0,
13691                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13692 }
13693
13694 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
13695 {
13696         struct alc_spec *spec = codec->spec;
13697         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
13698         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
13699         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
13700         unsigned int    dac_vol1, dac_vol2;
13701
13702         if (line_nid == 0x1d || speaker_nid == 0x1d) {
13703                 snd_hda_codec_write(codec, speaker_nid, 0,
13704                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13705                 /* mute mixer inputs from 0x1d */
13706                 snd_hda_codec_write(codec, 0x0f, 0,
13707                                     AC_VERB_SET_AMP_GAIN_MUTE,
13708                                     AMP_IN_UNMUTE(1));
13709                 snd_hda_codec_write(codec, 0x10, 0,
13710                                     AC_VERB_SET_AMP_GAIN_MUTE,
13711                                     AMP_IN_UNMUTE(1));
13712         } else {
13713                 /* unmute mixer inputs from 0x1d */
13714                 snd_hda_codec_write(codec, 0x0f, 0,
13715                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13716                 snd_hda_codec_write(codec, 0x10, 0,
13717                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13718         }
13719
13720         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
13721         if (line_nid == 0x14)
13722                 dac_vol2 = AMP_OUT_ZERO;
13723         else if (line_nid == 0x15)
13724                 dac_vol1 = AMP_OUT_ZERO;
13725         if (hp_nid == 0x14)
13726                 dac_vol2 = AMP_OUT_ZERO;
13727         else if (hp_nid == 0x15)
13728                 dac_vol1 = AMP_OUT_ZERO;
13729         if (line_nid != 0x16 || hp_nid != 0x16 ||
13730             spec->autocfg.line_out_pins[1] != 0x16 ||
13731             spec->autocfg.line_out_pins[2] != 0x16)
13732                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
13733
13734         snd_hda_codec_write(codec, 0x02, 0,
13735                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
13736         snd_hda_codec_write(codec, 0x03, 0,
13737                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
13738 }
13739
13740 /* pcm configuration: identical with ALC880 */
13741 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
13742 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
13743 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
13744 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
13745
13746 /*
13747  * BIOS auto configuration
13748  */
13749 static int alc268_parse_auto_config(struct hda_codec *codec)
13750 {
13751         struct alc_spec *spec = codec->spec;
13752         int err;
13753         static hda_nid_t alc268_ignore[] = { 0 };
13754
13755         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13756                                            alc268_ignore);
13757         if (err < 0)
13758                 return err;
13759         if (!spec->autocfg.line_outs) {
13760                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13761                         spec->multiout.max_channels = 2;
13762                         spec->no_analog = 1;
13763                         goto dig_only;
13764                 }
13765                 return 0; /* can't find valid BIOS pin config */
13766         }
13767         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13768         if (err < 0)
13769                 return err;
13770         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13771         if (err < 0)
13772                 return err;
13773
13774         spec->multiout.max_channels = 2;
13775
13776  dig_only:
13777         /* digital only support output */
13778         alc_auto_parse_digital(codec);
13779         if (spec->kctls.list)
13780                 add_mixer(spec, spec->kctls.list);
13781
13782         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13783                 add_mixer(spec, alc268_beep_mixer);
13784
13785         add_verb(spec, alc268_volume_init_verbs);
13786         spec->num_mux_defs = 2;
13787         spec->input_mux = &spec->private_imux[0];
13788
13789         err = alc_auto_add_mic_boost(codec);
13790         if (err < 0)
13791                 return err;
13792
13793         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13794
13795         return 1;
13796 }
13797
13798 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
13799
13800 /* init callback for auto-configuration model -- overriding the default init */
13801 static void alc268_auto_init(struct hda_codec *codec)
13802 {
13803         struct alc_spec *spec = codec->spec;
13804         alc268_auto_init_multi_out(codec);
13805         alc268_auto_init_hp_out(codec);
13806         alc268_auto_init_mono_speaker_out(codec);
13807         alc268_auto_init_analog_input(codec);
13808         alc_auto_init_digital(codec);
13809         if (spec->unsol_event)
13810                 alc_inithook(codec);
13811 }
13812
13813 /*
13814  * configuration and preset
13815  */
13816 static const char * const alc268_models[ALC268_MODEL_LAST] = {
13817         [ALC267_QUANTA_IL1]     = "quanta-il1",
13818         [ALC268_3ST]            = "3stack",
13819         [ALC268_TOSHIBA]        = "toshiba",
13820         [ALC268_ACER]           = "acer",
13821         [ALC268_ACER_DMIC]      = "acer-dmic",
13822         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
13823         [ALC268_DELL]           = "dell",
13824         [ALC268_ZEPTO]          = "zepto",
13825 #ifdef CONFIG_SND_DEBUG
13826         [ALC268_TEST]           = "test",
13827 #endif
13828         [ALC268_AUTO]           = "auto",
13829 };
13830
13831 static struct snd_pci_quirk alc268_cfg_tbl[] = {
13832         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13833         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13834         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13835         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13836         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13837         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13838                                                 ALC268_ACER_ASPIRE_ONE),
13839         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13840         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13841                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13842         /* almost compatible with toshiba but with optional digital outs;
13843          * auto-probing seems working fine
13844          */
13845         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13846                            ALC268_AUTO),
13847         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13848         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13849         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13850         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13851         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13852         {}
13853 };
13854
13855 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
13856 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13857         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13858         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13859         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13860                            ALC268_TOSHIBA),
13861         {}
13862 };
13863
13864 static struct alc_config_preset alc268_presets[] = {
13865         [ALC267_QUANTA_IL1] = {
13866                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13867                             alc268_capture_nosrc_mixer },
13868                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13869                                 alc267_quanta_il1_verbs },
13870                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13871                 .dac_nids = alc268_dac_nids,
13872                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13873                 .adc_nids = alc268_adc_nids_alt,
13874                 .hp_nid = 0x03,
13875                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13876                 .channel_mode = alc268_modes,
13877                 .unsol_event = alc_sku_unsol_event,
13878                 .setup = alc267_quanta_il1_setup,
13879                 .init_hook = alc_inithook,
13880         },
13881         [ALC268_3ST] = {
13882                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13883                             alc268_beep_mixer },
13884                 .init_verbs = { alc268_base_init_verbs },
13885                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13886                 .dac_nids = alc268_dac_nids,
13887                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13888                 .adc_nids = alc268_adc_nids_alt,
13889                 .capsrc_nids = alc268_capsrc_nids,
13890                 .hp_nid = 0x03,
13891                 .dig_out_nid = ALC268_DIGOUT_NID,
13892                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13893                 .channel_mode = alc268_modes,
13894                 .input_mux = &alc268_capture_source,
13895         },
13896         [ALC268_TOSHIBA] = {
13897                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13898                             alc268_beep_mixer },
13899                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13900                                 alc268_toshiba_verbs },
13901                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13902                 .dac_nids = alc268_dac_nids,
13903                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13904                 .adc_nids = alc268_adc_nids_alt,
13905                 .capsrc_nids = alc268_capsrc_nids,
13906                 .hp_nid = 0x03,
13907                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13908                 .channel_mode = alc268_modes,
13909                 .input_mux = &alc268_capture_source,
13910                 .unsol_event = alc268_toshiba_unsol_event,
13911                 .setup = alc268_toshiba_setup,
13912                 .init_hook = alc268_toshiba_automute,
13913         },
13914         [ALC268_ACER] = {
13915                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13916                             alc268_beep_mixer },
13917                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13918                                 alc268_acer_verbs },
13919                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13920                 .dac_nids = alc268_dac_nids,
13921                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13922                 .adc_nids = alc268_adc_nids_alt,
13923                 .capsrc_nids = alc268_capsrc_nids,
13924                 .hp_nid = 0x02,
13925                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13926                 .channel_mode = alc268_modes,
13927                 .input_mux = &alc268_acer_capture_source,
13928                 .unsol_event = alc268_acer_unsol_event,
13929                 .init_hook = alc268_acer_init_hook,
13930         },
13931         [ALC268_ACER_DMIC] = {
13932                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13933                             alc268_beep_mixer },
13934                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13935                                 alc268_acer_verbs },
13936                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13937                 .dac_nids = alc268_dac_nids,
13938                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13939                 .adc_nids = alc268_adc_nids_alt,
13940                 .capsrc_nids = alc268_capsrc_nids,
13941                 .hp_nid = 0x02,
13942                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13943                 .channel_mode = alc268_modes,
13944                 .input_mux = &alc268_acer_dmic_capture_source,
13945                 .unsol_event = alc268_acer_unsol_event,
13946                 .init_hook = alc268_acer_init_hook,
13947         },
13948         [ALC268_ACER_ASPIRE_ONE] = {
13949                 .mixers = { alc268_acer_aspire_one_mixer,
13950                             alc268_beep_mixer,
13951                             alc268_capture_nosrc_mixer },
13952                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13953                                 alc268_acer_aspire_one_verbs },
13954                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13955                 .dac_nids = alc268_dac_nids,
13956                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13957                 .adc_nids = alc268_adc_nids_alt,
13958                 .capsrc_nids = alc268_capsrc_nids,
13959                 .hp_nid = 0x03,
13960                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13961                 .channel_mode = alc268_modes,
13962                 .unsol_event = alc268_acer_lc_unsol_event,
13963                 .setup = alc268_acer_lc_setup,
13964                 .init_hook = alc268_acer_lc_init_hook,
13965         },
13966         [ALC268_DELL] = {
13967                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
13968                             alc268_capture_nosrc_mixer },
13969                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13970                                 alc268_dell_verbs },
13971                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13972                 .dac_nids = alc268_dac_nids,
13973                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13974                 .adc_nids = alc268_adc_nids_alt,
13975                 .capsrc_nids = alc268_capsrc_nids,
13976                 .hp_nid = 0x02,
13977                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13978                 .channel_mode = alc268_modes,
13979                 .unsol_event = alc_sku_unsol_event,
13980                 .setup = alc268_dell_setup,
13981                 .init_hook = alc_inithook,
13982         },
13983         [ALC268_ZEPTO] = {
13984                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13985                             alc268_beep_mixer },
13986                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13987                                 alc268_toshiba_verbs },
13988                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13989                 .dac_nids = alc268_dac_nids,
13990                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13991                 .adc_nids = alc268_adc_nids_alt,
13992                 .capsrc_nids = alc268_capsrc_nids,
13993                 .hp_nid = 0x03,
13994                 .dig_out_nid = ALC268_DIGOUT_NID,
13995                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13996                 .channel_mode = alc268_modes,
13997                 .input_mux = &alc268_capture_source,
13998                 .setup = alc268_toshiba_setup,
13999                 .init_hook = alc268_toshiba_automute,
14000         },
14001 #ifdef CONFIG_SND_DEBUG
14002         [ALC268_TEST] = {
14003                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
14004                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
14005                                 alc268_volume_init_verbs },
14006                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
14007                 .dac_nids = alc268_dac_nids,
14008                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
14009                 .adc_nids = alc268_adc_nids_alt,
14010                 .capsrc_nids = alc268_capsrc_nids,
14011                 .hp_nid = 0x03,
14012                 .dig_out_nid = ALC268_DIGOUT_NID,
14013                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
14014                 .channel_mode = alc268_modes,
14015                 .input_mux = &alc268_capture_source,
14016         },
14017 #endif
14018 };
14019
14020 static int patch_alc268(struct hda_codec *codec)
14021 {
14022         struct alc_spec *spec;
14023         int board_config;
14024         int i, has_beep, err;
14025
14026         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14027         if (spec == NULL)
14028                 return -ENOMEM;
14029
14030         codec->spec = spec;
14031
14032         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
14033                                                   alc268_models,
14034                                                   alc268_cfg_tbl);
14035
14036         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
14037                 board_config = snd_hda_check_board_codec_sid_config(codec,
14038                         ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
14039
14040         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
14041                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14042                        codec->chip_name);
14043                 board_config = ALC268_AUTO;
14044         }
14045
14046         if (board_config == ALC268_AUTO) {
14047                 /* automatic parse from the BIOS config */
14048                 err = alc268_parse_auto_config(codec);
14049                 if (err < 0) {
14050                         alc_free(codec);
14051                         return err;
14052                 } else if (!err) {
14053                         printk(KERN_INFO
14054                                "hda_codec: Cannot set up configuration "
14055                                "from BIOS.  Using base mode...\n");
14056                         board_config = ALC268_3ST;
14057                 }
14058         }
14059
14060         if (board_config != ALC268_AUTO)
14061                 setup_preset(codec, &alc268_presets[board_config]);
14062
14063         spec->stream_analog_playback = &alc268_pcm_analog_playback;
14064         spec->stream_analog_capture = &alc268_pcm_analog_capture;
14065         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
14066
14067         spec->stream_digital_playback = &alc268_pcm_digital_playback;
14068
14069         has_beep = 0;
14070         for (i = 0; i < spec->num_mixers; i++) {
14071                 if (spec->mixers[i] == alc268_beep_mixer) {
14072                         has_beep = 1;
14073                         break;
14074                 }
14075         }
14076
14077         if (has_beep) {
14078                 err = snd_hda_attach_beep_device(codec, 0x1);
14079                 if (err < 0) {
14080                         alc_free(codec);
14081                         return err;
14082                 }
14083                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
14084                         /* override the amp caps for beep generator */
14085                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
14086                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
14087                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
14088                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
14089                                           (0 << AC_AMPCAP_MUTE_SHIFT));
14090         }
14091
14092         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
14093                 /* check whether NID 0x07 is valid */
14094                 unsigned int wcap = get_wcaps(codec, 0x07);
14095                 int i;
14096
14097                 spec->capsrc_nids = alc268_capsrc_nids;
14098                 /* get type */
14099                 wcap = get_wcaps_type(wcap);
14100                 if (spec->auto_mic ||
14101                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
14102                         spec->adc_nids = alc268_adc_nids_alt;
14103                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
14104                         if (spec->auto_mic)
14105                                 fixup_automic_adc(codec);
14106                         if (spec->auto_mic || spec->input_mux->num_items == 1)
14107                                 add_mixer(spec, alc268_capture_nosrc_mixer);
14108                         else
14109                                 add_mixer(spec, alc268_capture_alt_mixer);
14110                 } else {
14111                         spec->adc_nids = alc268_adc_nids;
14112                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
14113                         add_mixer(spec, alc268_capture_mixer);
14114                 }
14115                 /* set default input source */
14116                 for (i = 0; i < spec->num_adc_nids; i++)
14117                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
14118                                 0, AC_VERB_SET_CONNECT_SEL,
14119                                 i < spec->num_mux_defs ?
14120                                 spec->input_mux[i].items[0].index :
14121                                 spec->input_mux->items[0].index);
14122         }
14123
14124         spec->vmaster_nid = 0x02;
14125
14126         codec->patch_ops = alc_patch_ops;
14127         if (board_config == ALC268_AUTO)
14128                 spec->init_hook = alc268_auto_init;
14129
14130         alc_init_jacks(codec);
14131
14132         return 0;
14133 }
14134
14135 /*
14136  *  ALC269 channel source setting (2 channel)
14137  */
14138 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
14139
14140 #define alc269_dac_nids         alc260_dac_nids
14141
14142 static hda_nid_t alc269_adc_nids[1] = {
14143         /* ADC1 */
14144         0x08,
14145 };
14146
14147 static hda_nid_t alc269_capsrc_nids[1] = {
14148         0x23,
14149 };
14150
14151 static hda_nid_t alc269vb_adc_nids[1] = {
14152         /* ADC1 */
14153         0x09,
14154 };
14155
14156 static hda_nid_t alc269vb_capsrc_nids[1] = {
14157         0x22,
14158 };
14159
14160 static hda_nid_t alc269_adc_candidates[] = {
14161         0x08, 0x09, 0x07,
14162 };
14163
14164 #define alc269_modes            alc260_modes
14165 #define alc269_capture_source   alc880_lg_lw_capture_source
14166
14167 static struct snd_kcontrol_new alc269_base_mixer[] = {
14168         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14169         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14170         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14171         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14172         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14173         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14174         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14175         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14176         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14177         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
14178         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14179         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
14180         { } /* end */
14181 };
14182
14183 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
14184         /* output mixer control */
14185         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14186         {
14187                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14188                 .name = "Master Playback Switch",
14189                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14190                 .info = snd_hda_mixer_amp_switch_info,
14191                 .get = snd_hda_mixer_amp_switch_get,
14192                 .put = alc268_acer_master_sw_put,
14193                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14194         },
14195         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14196         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14197         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14198         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14199         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14200         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14201         { }
14202 };
14203
14204 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
14205         /* output mixer control */
14206         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14207         {
14208                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14209                 .name = "Master Playback Switch",
14210                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14211                 .info = snd_hda_mixer_amp_switch_info,
14212                 .get = snd_hda_mixer_amp_switch_get,
14213                 .put = alc268_acer_master_sw_put,
14214                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14215         },
14216         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14217         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14218         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14219         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14220         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14221         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14222         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
14223         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
14224         HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x1b, 0, HDA_INPUT),
14225         { }
14226 };
14227
14228 static struct snd_kcontrol_new alc269_laptop_mixer[] = {
14229         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14230         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14231         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14232         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14233         { } /* end */
14234 };
14235
14236 static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
14237         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14238         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14239         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14240         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14241         { } /* end */
14242 };
14243
14244 static struct snd_kcontrol_new alc269_asus_mixer[] = {
14245         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14246         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
14247         { } /* end */
14248 };
14249
14250 /* capture mixer elements */
14251 static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
14252         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14253         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14254         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14255         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14256         { } /* end */
14257 };
14258
14259 static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
14260         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14261         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14262         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14263         { } /* end */
14264 };
14265
14266 static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
14267         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14268         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14269         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14270         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14271         { } /* end */
14272 };
14273
14274 static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
14275         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14276         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14277         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14278         { } /* end */
14279 };
14280
14281 /* FSC amilo */
14282 #define alc269_fujitsu_mixer    alc269_laptop_mixer
14283
14284 static struct hda_verb alc269_quanta_fl1_verbs[] = {
14285         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14286         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14287         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14288         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14289         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14290         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14291         { }
14292 };
14293
14294 static struct hda_verb alc269_lifebook_verbs[] = {
14295         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14296         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
14297         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14298         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14299         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14300         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14301         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14302         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14303         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14304         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14305         { }
14306 };
14307
14308 /* toggle speaker-output according to the hp-jack state */
14309 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
14310 {
14311         unsigned int present;
14312         unsigned char bits;
14313
14314         present = snd_hda_jack_detect(codec, 0x15);
14315         bits = present ? HDA_AMP_MUTE : 0;
14316         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14317                                  HDA_AMP_MUTE, bits);
14318         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14319                                  HDA_AMP_MUTE, bits);
14320
14321         snd_hda_codec_write(codec, 0x20, 0,
14322                         AC_VERB_SET_COEF_INDEX, 0x0c);
14323         snd_hda_codec_write(codec, 0x20, 0,
14324                         AC_VERB_SET_PROC_COEF, 0x680);
14325
14326         snd_hda_codec_write(codec, 0x20, 0,
14327                         AC_VERB_SET_COEF_INDEX, 0x0c);
14328         snd_hda_codec_write(codec, 0x20, 0,
14329                         AC_VERB_SET_PROC_COEF, 0x480);
14330 }
14331
14332 /* toggle speaker-output according to the hp-jacks state */
14333 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
14334 {
14335         unsigned int present;
14336         unsigned char bits;
14337
14338         /* Check laptop headphone socket */
14339         present = snd_hda_jack_detect(codec, 0x15);
14340
14341         /* Check port replicator headphone socket */
14342         present |= snd_hda_jack_detect(codec, 0x1a);
14343
14344         bits = present ? HDA_AMP_MUTE : 0;
14345         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14346                                  HDA_AMP_MUTE, bits);
14347         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14348                                  HDA_AMP_MUTE, bits);
14349
14350         snd_hda_codec_write(codec, 0x20, 0,
14351                         AC_VERB_SET_COEF_INDEX, 0x0c);
14352         snd_hda_codec_write(codec, 0x20, 0,
14353                         AC_VERB_SET_PROC_COEF, 0x680);
14354
14355         snd_hda_codec_write(codec, 0x20, 0,
14356                         AC_VERB_SET_COEF_INDEX, 0x0c);
14357         snd_hda_codec_write(codec, 0x20, 0,
14358                         AC_VERB_SET_PROC_COEF, 0x480);
14359 }
14360
14361 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
14362 {
14363         unsigned int present_laptop;
14364         unsigned int present_dock;
14365
14366         present_laptop  = snd_hda_jack_detect(codec, 0x18);
14367         present_dock    = snd_hda_jack_detect(codec, 0x1b);
14368
14369         /* Laptop mic port overrides dock mic port, design decision */
14370         if (present_dock)
14371                 snd_hda_codec_write(codec, 0x23, 0,
14372                                 AC_VERB_SET_CONNECT_SEL, 0x3);
14373         if (present_laptop)
14374                 snd_hda_codec_write(codec, 0x23, 0,
14375                                 AC_VERB_SET_CONNECT_SEL, 0x0);
14376         if (!present_dock && !present_laptop)
14377                 snd_hda_codec_write(codec, 0x23, 0,
14378                                 AC_VERB_SET_CONNECT_SEL, 0x1);
14379 }
14380
14381 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
14382                                     unsigned int res)
14383 {
14384         switch (res >> 26) {
14385         case ALC880_HP_EVENT:
14386                 alc269_quanta_fl1_speaker_automute(codec);
14387                 break;
14388         case ALC880_MIC_EVENT:
14389                 alc_mic_automute(codec);
14390                 break;
14391         }
14392 }
14393
14394 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
14395                                         unsigned int res)
14396 {
14397         if ((res >> 26) == ALC880_HP_EVENT)
14398                 alc269_lifebook_speaker_automute(codec);
14399         if ((res >> 26) == ALC880_MIC_EVENT)
14400                 alc269_lifebook_mic_autoswitch(codec);
14401 }
14402
14403 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
14404 {
14405         struct alc_spec *spec = codec->spec;
14406         spec->autocfg.hp_pins[0] = 0x15;
14407         spec->autocfg.speaker_pins[0] = 0x14;
14408         spec->ext_mic.pin = 0x18;
14409         spec->ext_mic.mux_idx = 0;
14410         spec->int_mic.pin = 0x19;
14411         spec->int_mic.mux_idx = 1;
14412         spec->auto_mic = 1;
14413 }
14414
14415 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
14416 {
14417         alc269_quanta_fl1_speaker_automute(codec);
14418         alc_mic_automute(codec);
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 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 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 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 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 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 /* toggle speaker-output according to the hp-jack state */
14485 static void alc269_speaker_automute(struct hda_codec *codec)
14486 {
14487         struct alc_spec *spec = codec->spec;
14488         unsigned int nid = spec->autocfg.hp_pins[0];
14489         unsigned int present;
14490         unsigned char bits;
14491
14492         present = snd_hda_jack_detect(codec, nid);
14493         bits = present ? HDA_AMP_MUTE : 0;
14494         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14495                                  HDA_AMP_MUTE, bits);
14496         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14497                                  HDA_AMP_MUTE, bits);
14498         alc_report_jack(codec, nid);
14499 }
14500
14501 /* unsolicited event for HP jack sensing */
14502 static void alc269_laptop_unsol_event(struct hda_codec *codec,
14503                                      unsigned int res)
14504 {
14505         switch (res >> 26) {
14506         case ALC880_HP_EVENT:
14507                 alc269_speaker_automute(codec);
14508                 break;
14509         case ALC880_MIC_EVENT:
14510                 alc_mic_automute(codec);
14511                 break;
14512         }
14513 }
14514
14515 static void alc269_laptop_amic_setup(struct hda_codec *codec)
14516 {
14517         struct alc_spec *spec = codec->spec;
14518         spec->autocfg.hp_pins[0] = 0x15;
14519         spec->autocfg.speaker_pins[0] = 0x14;
14520         spec->ext_mic.pin = 0x18;
14521         spec->ext_mic.mux_idx = 0;
14522         spec->int_mic.pin = 0x19;
14523         spec->int_mic.mux_idx = 1;
14524         spec->auto_mic = 1;
14525 }
14526
14527 static void alc269_laptop_dmic_setup(struct hda_codec *codec)
14528 {
14529         struct alc_spec *spec = codec->spec;
14530         spec->autocfg.hp_pins[0] = 0x15;
14531         spec->autocfg.speaker_pins[0] = 0x14;
14532         spec->ext_mic.pin = 0x18;
14533         spec->ext_mic.mux_idx = 0;
14534         spec->int_mic.pin = 0x12;
14535         spec->int_mic.mux_idx = 5;
14536         spec->auto_mic = 1;
14537 }
14538
14539 static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
14540 {
14541         struct alc_spec *spec = codec->spec;
14542         spec->autocfg.hp_pins[0] = 0x21;
14543         spec->autocfg.speaker_pins[0] = 0x14;
14544         spec->ext_mic.pin = 0x18;
14545         spec->ext_mic.mux_idx = 0;
14546         spec->int_mic.pin = 0x19;
14547         spec->int_mic.mux_idx = 1;
14548         spec->auto_mic = 1;
14549 }
14550
14551 static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
14552 {
14553         struct alc_spec *spec = codec->spec;
14554         spec->autocfg.hp_pins[0] = 0x21;
14555         spec->autocfg.speaker_pins[0] = 0x14;
14556         spec->ext_mic.pin = 0x18;
14557         spec->ext_mic.mux_idx = 0;
14558         spec->int_mic.pin = 0x12;
14559         spec->int_mic.mux_idx = 6;
14560         spec->auto_mic = 1;
14561 }
14562
14563 static void alc269_laptop_inithook(struct hda_codec *codec)
14564 {
14565         alc269_speaker_automute(codec);
14566         alc_mic_automute(codec);
14567 }
14568
14569 /*
14570  * generic initialization of ADC, input mixers and output mixers
14571  */
14572 static struct hda_verb alc269_init_verbs[] = {
14573         /*
14574          * Unmute ADC0 and set the default input to mic-in
14575          */
14576         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14577
14578         /*
14579          * Set up output mixers (0x02 - 0x03)
14580          */
14581         /* set vol=0 to output mixers */
14582         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14583         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14584
14585         /* set up input amps for analog loopback */
14586         /* Amp Indices: DAC = 0, mixer = 1 */
14587         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14588         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14589         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14590         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14591         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14592         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14593
14594         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14595         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14596         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14597         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14598         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14599         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14600         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14601
14602         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14603         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14604
14605         /* FIXME: use Mux-type input source selection */
14606         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14607         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14608         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
14609
14610         /* set EAPD */
14611         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14612         { }
14613 };
14614
14615 static struct hda_verb alc269vb_init_verbs[] = {
14616         /*
14617          * Unmute ADC0 and set the default input to mic-in
14618          */
14619         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14620
14621         /*
14622          * Set up output mixers (0x02 - 0x03)
14623          */
14624         /* set vol=0 to output mixers */
14625         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14626         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14627
14628         /* set up input amps for analog loopback */
14629         /* Amp Indices: DAC = 0, mixer = 1 */
14630         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14631         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14632         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14633         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14634         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14635         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14636
14637         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14638         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14639         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14640         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14641         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14642         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14643         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14644
14645         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14646         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14647
14648         /* FIXME: use Mux-type input source selection */
14649         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14650         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14651         {0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
14652
14653         /* set EAPD */
14654         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14655         { }
14656 };
14657
14658 #define alc269_auto_create_multi_out_ctls \
14659         alc268_auto_create_multi_out_ctls
14660 #define alc269_auto_create_input_ctls \
14661         alc268_auto_create_input_ctls
14662
14663 #ifdef CONFIG_SND_HDA_POWER_SAVE
14664 #define alc269_loopbacks        alc880_loopbacks
14665 #endif
14666
14667 /* pcm configuration: identical with ALC880 */
14668 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
14669 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
14670 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
14671 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
14672
14673 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
14674         .substreams = 1,
14675         .channels_min = 2,
14676         .channels_max = 8,
14677         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14678         /* NID is set in alc_build_pcms */
14679         .ops = {
14680                 .open = alc880_playback_pcm_open,
14681                 .prepare = alc880_playback_pcm_prepare,
14682                 .cleanup = alc880_playback_pcm_cleanup
14683         },
14684 };
14685
14686 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
14687         .substreams = 1,
14688         .channels_min = 2,
14689         .channels_max = 2,
14690         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14691         /* NID is set in alc_build_pcms */
14692 };
14693
14694 #ifdef CONFIG_SND_HDA_POWER_SAVE
14695 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
14696 {
14697         switch (codec->subsystem_id) {
14698         case 0x103c1586:
14699                 return 1;
14700         }
14701         return 0;
14702 }
14703
14704 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
14705 {
14706         /* update mute-LED according to the speaker mute state */
14707         if (nid == 0x01 || nid == 0x14) {
14708                 int pinval;
14709                 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
14710                     HDA_AMP_MUTE)
14711                         pinval = 0x24;
14712                 else
14713                         pinval = 0x20;
14714                 /* mic2 vref pin is used for mute LED control */
14715                 snd_hda_codec_update_cache(codec, 0x19, 0,
14716                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
14717                                            pinval);
14718         }
14719         return alc_check_power_status(codec, nid);
14720 }
14721 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14722
14723 static int alc275_setup_dual_adc(struct hda_codec *codec)
14724 {
14725         struct alc_spec *spec = codec->spec;
14726
14727         if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
14728                 return 0;
14729         if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
14730             (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
14731                 if (spec->ext_mic.pin <= 0x12) {
14732                         spec->private_adc_nids[0] = 0x08;
14733                         spec->private_adc_nids[1] = 0x11;
14734                         spec->private_capsrc_nids[0] = 0x23;
14735                         spec->private_capsrc_nids[1] = 0x22;
14736                 } else {
14737                         spec->private_adc_nids[0] = 0x11;
14738                         spec->private_adc_nids[1] = 0x08;
14739                         spec->private_capsrc_nids[0] = 0x22;
14740                         spec->private_capsrc_nids[1] = 0x23;
14741                 }
14742                 spec->adc_nids = spec->private_adc_nids;
14743                 spec->capsrc_nids = spec->private_capsrc_nids;
14744                 spec->num_adc_nids = 2;
14745                 spec->dual_adc_switch = 1;
14746                 snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
14747                             spec->adc_nids[0], spec->adc_nids[1]);
14748                 return 1;
14749         }
14750         return 0;
14751 }
14752
14753 /* different alc269-variants */
14754 enum {
14755         ALC269_TYPE_NORMAL,
14756         ALC269_TYPE_ALC258,
14757         ALC269_TYPE_ALC259,
14758         ALC269_TYPE_ALC269VB,
14759         ALC269_TYPE_ALC270,
14760         ALC269_TYPE_ALC271X,
14761 };
14762
14763 /*
14764  * BIOS auto configuration
14765  */
14766 static int alc269_parse_auto_config(struct hda_codec *codec)
14767 {
14768         struct alc_spec *spec = codec->spec;
14769         int err;
14770         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
14771
14772         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14773                                            alc269_ignore);
14774         if (err < 0)
14775                 return err;
14776
14777         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
14778         if (err < 0)
14779                 return err;
14780         if (spec->codec_variant == ALC269_TYPE_NORMAL)
14781                 err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
14782         else
14783                 err = alc_auto_create_input_ctls(codec, &spec->autocfg, 0,
14784                                                  0x22, 0);
14785         if (err < 0)
14786                 return err;
14787
14788         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14789
14790         alc_auto_parse_digital(codec);
14791
14792         if (spec->kctls.list)
14793                 add_mixer(spec, spec->kctls.list);
14794
14795         if (spec->codec_variant != ALC269_TYPE_NORMAL) {
14796                 add_verb(spec, alc269vb_init_verbs);
14797                 alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
14798         } else {
14799                 add_verb(spec, alc269_init_verbs);
14800                 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
14801         }
14802
14803         spec->num_mux_defs = 1;
14804         spec->input_mux = &spec->private_imux[0];
14805
14806         if (!alc275_setup_dual_adc(codec))
14807                 fillup_priv_adc_nids(codec, alc269_adc_candidates,
14808                                      sizeof(alc269_adc_candidates));
14809
14810         /* set default input source */
14811         if (!spec->dual_adc_switch)
14812                 select_or_unmute_capsrc(codec, spec->capsrc_nids[0],
14813                                         spec->input_mux->items[0].index);
14814
14815         err = alc_auto_add_mic_boost(codec);
14816         if (err < 0)
14817                 return err;
14818
14819         if (!spec->cap_mixer && !spec->no_analog)
14820                 set_capture_mixer(codec);
14821
14822         return 1;
14823 }
14824
14825 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
14826 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
14827 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
14828
14829
14830 /* init callback for auto-configuration model -- overriding the default init */
14831 static void alc269_auto_init(struct hda_codec *codec)
14832 {
14833         struct alc_spec *spec = codec->spec;
14834         alc269_auto_init_multi_out(codec);
14835         alc269_auto_init_hp_out(codec);
14836         alc269_auto_init_analog_input(codec);
14837         alc_auto_init_digital(codec);
14838         if (spec->unsol_event)
14839                 alc_inithook(codec);
14840 }
14841
14842 #ifdef SND_HDA_NEEDS_RESUME
14843 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
14844 {
14845         int val = alc_read_coef_idx(codec, 0x04);
14846         if (power_up)
14847                 val |= 1 << 11;
14848         else
14849                 val &= ~(1 << 11);
14850         alc_write_coef_idx(codec, 0x04, val);
14851 }
14852
14853 #ifdef CONFIG_SND_HDA_POWER_SAVE
14854 static int alc269_suspend(struct hda_codec *codec, pm_message_t state)
14855 {
14856         struct alc_spec *spec = codec->spec;
14857
14858         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
14859                 alc269_toggle_power_output(codec, 0);
14860         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14861                 alc269_toggle_power_output(codec, 0);
14862                 msleep(150);
14863         }
14864
14865         alc_shutup(codec);
14866         if (spec && spec->power_hook)
14867                 spec->power_hook(codec);
14868         return 0;
14869 }
14870 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14871
14872 static int alc269_resume(struct hda_codec *codec)
14873 {
14874         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14875                 alc269_toggle_power_output(codec, 0);
14876                 msleep(150);
14877         }
14878
14879         codec->patch_ops.init(codec);
14880
14881         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14882                 alc269_toggle_power_output(codec, 1);
14883                 msleep(200);
14884         }
14885
14886         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
14887                 alc269_toggle_power_output(codec, 1);
14888
14889         snd_hda_codec_resume_amp(codec);
14890         snd_hda_codec_resume_cache(codec);
14891         hda_call_check_power_status(codec, 0x01);
14892         return 0;
14893 }
14894 #endif /* SND_HDA_NEEDS_RESUME */
14895
14896 static void alc269_fixup_hweq(struct hda_codec *codec,
14897                                const struct alc_fixup *fix, int action)
14898 {
14899         int coef;
14900
14901         if (action != ALC_FIXUP_ACT_INIT)
14902                 return;
14903         coef = alc_read_coef_idx(codec, 0x1e);
14904         alc_write_coef_idx(codec, 0x1e, coef | 0x80);
14905 }
14906
14907 enum {
14908         ALC269_FIXUP_SONY_VAIO,
14909         ALC275_FIXUP_SONY_VAIO_GPIO2,
14910         ALC269_FIXUP_DELL_M101Z,
14911         ALC269_FIXUP_SKU_IGNORE,
14912         ALC269_FIXUP_ASUS_G73JW,
14913         ALC269_FIXUP_LENOVO_EAPD,
14914         ALC275_FIXUP_SONY_HWEQ,
14915 };
14916
14917 static const struct alc_fixup alc269_fixups[] = {
14918         [ALC269_FIXUP_SONY_VAIO] = {
14919                 .type = ALC_FIXUP_VERBS,
14920                 .v.verbs = (const struct hda_verb[]) {
14921                         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14922                         {}
14923                 }
14924         },
14925         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
14926                 .type = ALC_FIXUP_VERBS,
14927                 .v.verbs = (const struct hda_verb[]) {
14928                         {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
14929                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
14930                         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
14931                         { }
14932                 },
14933                 .chained = true,
14934                 .chain_id = ALC269_FIXUP_SONY_VAIO
14935         },
14936         [ALC269_FIXUP_DELL_M101Z] = {
14937                 .type = ALC_FIXUP_VERBS,
14938                 .v.verbs = (const struct hda_verb[]) {
14939                         /* Enables internal speaker */
14940                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
14941                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
14942                         {}
14943                 }
14944         },
14945         [ALC269_FIXUP_SKU_IGNORE] = {
14946                 .type = ALC_FIXUP_SKU,
14947                 .v.sku = ALC_FIXUP_SKU_IGNORE,
14948         },
14949         [ALC269_FIXUP_ASUS_G73JW] = {
14950                 .type = ALC_FIXUP_PINS,
14951                 .v.pins = (const struct alc_pincfg[]) {
14952                         { 0x17, 0x99130111 }, /* subwoofer */
14953                         { }
14954                 }
14955         },
14956         [ALC269_FIXUP_LENOVO_EAPD] = {
14957                 .type = ALC_FIXUP_VERBS,
14958                 .v.verbs = (const struct hda_verb[]) {
14959                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
14960                         {}
14961                 }
14962         },
14963         [ALC275_FIXUP_SONY_HWEQ] = {
14964                 .type = ALC_FIXUP_FUNC,
14965                 .v.func = alc269_fixup_hweq,
14966                 .chained = true,
14967                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
14968         }
14969 };
14970
14971 static struct snd_pci_quirk alc269_fixup_tbl[] = {
14972         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
14973         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
14974         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
14975         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14976         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
14977         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
14978         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
14979         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
14980         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
14981         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
14982         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
14983         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
14984         {}
14985 };
14986
14987
14988 /*
14989  * configuration and preset
14990  */
14991 static const char * const alc269_models[ALC269_MODEL_LAST] = {
14992         [ALC269_BASIC]                  = "basic",
14993         [ALC269_QUANTA_FL1]             = "quanta",
14994         [ALC269_AMIC]                   = "laptop-amic",
14995         [ALC269_DMIC]                   = "laptop-dmic",
14996         [ALC269_FUJITSU]                = "fujitsu",
14997         [ALC269_LIFEBOOK]               = "lifebook",
14998         [ALC269_AUTO]                   = "auto",
14999 };
15000
15001 static struct snd_pci_quirk alc269_cfg_tbl[] = {
15002         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
15003         SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
15004         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
15005                       ALC269_AMIC),
15006         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
15007         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
15008         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
15009         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
15010         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
15011         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
15012         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
15013         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
15014         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
15015         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_AMIC),
15016         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
15017         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
15018         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
15019         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
15020         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
15021         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
15022         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
15023         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
15024         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
15025         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
15026         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
15027         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
15028         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
15029         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
15030         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
15031         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
15032         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
15033         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
15034         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
15035         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
15036         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
15037         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
15038         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
15039         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
15040         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
15041         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
15042         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
15043                       ALC269_DMIC),
15044         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
15045                       ALC269_DMIC),
15046         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
15047         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
15048         SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
15049         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
15050         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
15051         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
15052         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
15053         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
15054         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
15055         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
15056         {}
15057 };
15058
15059 static struct alc_config_preset alc269_presets[] = {
15060         [ALC269_BASIC] = {
15061                 .mixers = { alc269_base_mixer },
15062                 .init_verbs = { alc269_init_verbs },
15063                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15064                 .dac_nids = alc269_dac_nids,
15065                 .hp_nid = 0x03,
15066                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15067                 .channel_mode = alc269_modes,
15068                 .input_mux = &alc269_capture_source,
15069         },
15070         [ALC269_QUANTA_FL1] = {
15071                 .mixers = { alc269_quanta_fl1_mixer },
15072                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
15073                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15074                 .dac_nids = alc269_dac_nids,
15075                 .hp_nid = 0x03,
15076                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15077                 .channel_mode = alc269_modes,
15078                 .input_mux = &alc269_capture_source,
15079                 .unsol_event = alc269_quanta_fl1_unsol_event,
15080                 .setup = alc269_quanta_fl1_setup,
15081                 .init_hook = alc269_quanta_fl1_init_hook,
15082         },
15083         [ALC269_AMIC] = {
15084                 .mixers = { alc269_laptop_mixer },
15085                 .cap_mixer = alc269_laptop_analog_capture_mixer,
15086                 .init_verbs = { alc269_init_verbs,
15087                                 alc269_laptop_amic_init_verbs },
15088                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15089                 .dac_nids = alc269_dac_nids,
15090                 .hp_nid = 0x03,
15091                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15092                 .channel_mode = alc269_modes,
15093                 .unsol_event = alc269_laptop_unsol_event,
15094                 .setup = alc269_laptop_amic_setup,
15095                 .init_hook = alc269_laptop_inithook,
15096         },
15097         [ALC269_DMIC] = {
15098                 .mixers = { alc269_laptop_mixer },
15099                 .cap_mixer = alc269_laptop_digital_capture_mixer,
15100                 .init_verbs = { alc269_init_verbs,
15101                                 alc269_laptop_dmic_init_verbs },
15102                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15103                 .dac_nids = alc269_dac_nids,
15104                 .hp_nid = 0x03,
15105                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15106                 .channel_mode = alc269_modes,
15107                 .unsol_event = alc269_laptop_unsol_event,
15108                 .setup = alc269_laptop_dmic_setup,
15109                 .init_hook = alc269_laptop_inithook,
15110         },
15111         [ALC269VB_AMIC] = {
15112                 .mixers = { alc269vb_laptop_mixer },
15113                 .cap_mixer = alc269vb_laptop_analog_capture_mixer,
15114                 .init_verbs = { alc269vb_init_verbs,
15115                                 alc269vb_laptop_amic_init_verbs },
15116                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15117                 .dac_nids = alc269_dac_nids,
15118                 .hp_nid = 0x03,
15119                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15120                 .channel_mode = alc269_modes,
15121                 .unsol_event = alc269_laptop_unsol_event,
15122                 .setup = alc269vb_laptop_amic_setup,
15123                 .init_hook = alc269_laptop_inithook,
15124         },
15125         [ALC269VB_DMIC] = {
15126                 .mixers = { alc269vb_laptop_mixer },
15127                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
15128                 .init_verbs = { alc269vb_init_verbs,
15129                                 alc269vb_laptop_dmic_init_verbs },
15130                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15131                 .dac_nids = alc269_dac_nids,
15132                 .hp_nid = 0x03,
15133                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15134                 .channel_mode = alc269_modes,
15135                 .unsol_event = alc269_laptop_unsol_event,
15136                 .setup = alc269vb_laptop_dmic_setup,
15137                 .init_hook = alc269_laptop_inithook,
15138         },
15139         [ALC269_FUJITSU] = {
15140                 .mixers = { alc269_fujitsu_mixer },
15141                 .cap_mixer = alc269_laptop_digital_capture_mixer,
15142                 .init_verbs = { alc269_init_verbs,
15143                                 alc269_laptop_dmic_init_verbs },
15144                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15145                 .dac_nids = alc269_dac_nids,
15146                 .hp_nid = 0x03,
15147                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15148                 .channel_mode = alc269_modes,
15149                 .unsol_event = alc269_laptop_unsol_event,
15150                 .setup = alc269_laptop_dmic_setup,
15151                 .init_hook = alc269_laptop_inithook,
15152         },
15153         [ALC269_LIFEBOOK] = {
15154                 .mixers = { alc269_lifebook_mixer },
15155                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
15156                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15157                 .dac_nids = alc269_dac_nids,
15158                 .hp_nid = 0x03,
15159                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15160                 .channel_mode = alc269_modes,
15161                 .input_mux = &alc269_capture_source,
15162                 .unsol_event = alc269_lifebook_unsol_event,
15163                 .init_hook = alc269_lifebook_init_hook,
15164         },
15165         [ALC271_ACER] = {
15166                 .mixers = { alc269_asus_mixer },
15167                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
15168                 .init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
15169                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15170                 .dac_nids = alc269_dac_nids,
15171                 .adc_nids = alc262_dmic_adc_nids,
15172                 .num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
15173                 .capsrc_nids = alc262_dmic_capsrc_nids,
15174                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15175                 .channel_mode = alc269_modes,
15176                 .input_mux = &alc269_capture_source,
15177                 .dig_out_nid = ALC880_DIGOUT_NID,
15178                 .unsol_event = alc_sku_unsol_event,
15179                 .setup = alc269vb_laptop_dmic_setup,
15180                 .init_hook = alc_inithook,
15181         },
15182 };
15183
15184 static int alc269_fill_coef(struct hda_codec *codec)
15185 {
15186         int val;
15187
15188         if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
15189                 alc_write_coef_idx(codec, 0xf, 0x960b);
15190                 alc_write_coef_idx(codec, 0xe, 0x8817);
15191         }
15192
15193         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
15194                 alc_write_coef_idx(codec, 0xf, 0x960b);
15195                 alc_write_coef_idx(codec, 0xe, 0x8814);
15196         }
15197
15198         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
15199                 val = alc_read_coef_idx(codec, 0x04);
15200                 /* Power up output pin */
15201                 alc_write_coef_idx(codec, 0x04, val | (1<<11));
15202         }
15203
15204         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
15205                 val = alc_read_coef_idx(codec, 0xd);
15206                 if ((val & 0x0c00) >> 10 != 0x1) {
15207                         /* Capless ramp up clock control */
15208                         alc_write_coef_idx(codec, 0xd, val | 1<<10);
15209                 }
15210                 val = alc_read_coef_idx(codec, 0x17);
15211                 if ((val & 0x01c0) >> 6 != 0x4) {
15212                         /* Class D power on reset */
15213                         alc_write_coef_idx(codec, 0x17, val | 1<<7);
15214                 }
15215         }
15216         return 0;
15217 }
15218
15219 static int patch_alc269(struct hda_codec *codec)
15220 {
15221         struct alc_spec *spec;
15222         int board_config, coef;
15223         int err;
15224
15225         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15226         if (spec == NULL)
15227                 return -ENOMEM;
15228
15229         codec->spec = spec;
15230
15231         alc_auto_parse_customize_define(codec);
15232
15233         if (codec->vendor_id == 0x10ec0269) {
15234                 coef = alc_read_coef_idx(codec, 0);
15235                 if ((coef & 0x00f0) == 0x0010) {
15236                         if (codec->bus->pci->subsystem_vendor == 0x1025 &&
15237                             spec->cdefine.platform_type == 1) {
15238                                 alc_codec_rename(codec, "ALC271X");
15239                                 spec->codec_variant = ALC269_TYPE_ALC271X;
15240                         } else if ((coef & 0xf000) == 0x1000) {
15241                                 spec->codec_variant = ALC269_TYPE_ALC270;
15242                         } else if ((coef & 0xf000) == 0x2000) {
15243                                 alc_codec_rename(codec, "ALC259");
15244                                 spec->codec_variant = ALC269_TYPE_ALC259;
15245                         } else if ((coef & 0xf000) == 0x3000) {
15246                                 alc_codec_rename(codec, "ALC258");
15247                                 spec->codec_variant = ALC269_TYPE_ALC258;
15248                         } else {
15249                                 alc_codec_rename(codec, "ALC269VB");
15250                                 spec->codec_variant = ALC269_TYPE_ALC269VB;
15251                         }
15252                 } else
15253                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
15254                 alc269_fill_coef(codec);
15255         }
15256
15257         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
15258                                                   alc269_models,
15259                                                   alc269_cfg_tbl);
15260
15261         if (board_config < 0) {
15262                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15263                        codec->chip_name);
15264                 board_config = ALC269_AUTO;
15265         }
15266
15267         if (board_config == ALC269_AUTO) {
15268                 alc_pick_fixup(codec, NULL, alc269_fixup_tbl, alc269_fixups);
15269                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
15270         }
15271
15272         if (board_config == ALC269_AUTO) {
15273                 /* automatic parse from the BIOS config */
15274                 err = alc269_parse_auto_config(codec);
15275                 if (err < 0) {
15276                         alc_free(codec);
15277                         return err;
15278                 } else if (!err) {
15279                         printk(KERN_INFO
15280                                "hda_codec: Cannot set up configuration "
15281                                "from BIOS.  Using base mode...\n");
15282                         board_config = ALC269_BASIC;
15283                 }
15284         }
15285
15286         if (has_cdefine_beep(codec)) {
15287                 err = snd_hda_attach_beep_device(codec, 0x1);
15288                 if (err < 0) {
15289                         alc_free(codec);
15290                         return err;
15291                 }
15292         }
15293
15294         if (board_config != ALC269_AUTO)
15295                 setup_preset(codec, &alc269_presets[board_config]);
15296
15297         if (board_config == ALC269_QUANTA_FL1) {
15298                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
15299                  * fix the sample rate of analog I/O to 44.1kHz
15300                  */
15301                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
15302                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
15303         } else if (spec->dual_adc_switch) {
15304                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15305                 /* switch ADC dynamically */
15306                 spec->stream_analog_capture = &dualmic_pcm_analog_capture;
15307         } else {
15308                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15309                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
15310         }
15311         spec->stream_digital_playback = &alc269_pcm_digital_playback;
15312         spec->stream_digital_capture = &alc269_pcm_digital_capture;
15313
15314         if (!spec->adc_nids) { /* wasn't filled automatically? use default */
15315                 if (spec->codec_variant == ALC269_TYPE_NORMAL) {
15316                         spec->adc_nids = alc269_adc_nids;
15317                         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
15318                         spec->capsrc_nids = alc269_capsrc_nids;
15319                 } else {
15320                         spec->adc_nids = alc269vb_adc_nids;
15321                         spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
15322                         spec->capsrc_nids = alc269vb_capsrc_nids;
15323                 }
15324         }
15325
15326         if (!spec->cap_mixer)
15327                 set_capture_mixer(codec);
15328         if (has_cdefine_beep(codec))
15329                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
15330
15331         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
15332
15333         spec->vmaster_nid = 0x02;
15334
15335         codec->patch_ops = alc_patch_ops;
15336 #ifdef CONFIG_SND_HDA_POWER_SAVE
15337         codec->patch_ops.suspend = alc269_suspend;
15338 #endif
15339 #ifdef SND_HDA_NEEDS_RESUME
15340         codec->patch_ops.resume = alc269_resume;
15341 #endif
15342         if (board_config == ALC269_AUTO)
15343                 spec->init_hook = alc269_auto_init;
15344
15345         alc_init_jacks(codec);
15346 #ifdef CONFIG_SND_HDA_POWER_SAVE
15347         if (!spec->loopback.amplist)
15348                 spec->loopback.amplist = alc269_loopbacks;
15349         if (alc269_mic2_for_mute_led(codec))
15350                 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
15351 #endif
15352
15353         return 0;
15354 }
15355
15356 /*
15357  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
15358  */
15359
15360 /*
15361  * set the path ways for 2 channel output
15362  * need to set the codec line out and mic 1 pin widgets to inputs
15363  */
15364 static struct hda_verb alc861_threestack_ch2_init[] = {
15365         /* set pin widget 1Ah (line in) for input */
15366         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15367         /* set pin widget 18h (mic1/2) for input, for mic also enable
15368          * the vref
15369          */
15370         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15371
15372         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15373 #if 0
15374         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15375         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15376 #endif
15377         { } /* end */
15378 };
15379 /*
15380  * 6ch mode
15381  * need to set the codec line out and mic 1 pin widgets to outputs
15382  */
15383 static struct hda_verb alc861_threestack_ch6_init[] = {
15384         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15385         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15386         /* set pin widget 18h (mic1) for output (CLFE)*/
15387         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15388
15389         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15390         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15391
15392         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15393 #if 0
15394         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15395         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15396 #endif
15397         { } /* end */
15398 };
15399
15400 static struct hda_channel_mode alc861_threestack_modes[2] = {
15401         { 2, alc861_threestack_ch2_init },
15402         { 6, alc861_threestack_ch6_init },
15403 };
15404 /* Set mic1 as input and unmute the mixer */
15405 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
15406         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15407         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15408         { } /* end */
15409 };
15410 /* Set mic1 as output and mute mixer */
15411 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
15412         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15413         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15414         { } /* end */
15415 };
15416
15417 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
15418         { 2, alc861_uniwill_m31_ch2_init },
15419         { 4, alc861_uniwill_m31_ch4_init },
15420 };
15421
15422 /* Set mic1 and line-in as input and unmute the mixer */
15423 static struct hda_verb alc861_asus_ch2_init[] = {
15424         /* set pin widget 1Ah (line in) for input */
15425         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15426         /* set pin widget 18h (mic1/2) for input, for mic also enable
15427          * the vref
15428          */
15429         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15430
15431         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15432 #if 0
15433         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15434         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15435 #endif
15436         { } /* end */
15437 };
15438 /* Set mic1 nad line-in as output and mute mixer */
15439 static struct hda_verb alc861_asus_ch6_init[] = {
15440         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15441         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15442         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15443         /* set pin widget 18h (mic1) for output (CLFE)*/
15444         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15445         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15446         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15447         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15448
15449         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15450 #if 0
15451         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15452         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15453 #endif
15454         { } /* end */
15455 };
15456
15457 static struct hda_channel_mode alc861_asus_modes[2] = {
15458         { 2, alc861_asus_ch2_init },
15459         { 6, alc861_asus_ch6_init },
15460 };
15461
15462 /* patch-ALC861 */
15463
15464 static struct snd_kcontrol_new alc861_base_mixer[] = {
15465         /* output mixer control */
15466         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15467         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15468         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15469         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15470         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15471
15472         /*Input mixer control */
15473         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15474            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15475         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15476         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15477         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15478         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15479         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15480         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15481         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15482         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15483
15484         { } /* end */
15485 };
15486
15487 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
15488         /* output mixer control */
15489         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15490         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15491         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15492         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15493         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15494
15495         /* Input mixer control */
15496         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15497            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15498         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15499         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15500         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15501         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15502         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15503         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15504         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15505         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15506
15507         {
15508                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15509                 .name = "Channel Mode",
15510                 .info = alc_ch_mode_info,
15511                 .get = alc_ch_mode_get,
15512                 .put = alc_ch_mode_put,
15513                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
15514         },
15515         { } /* end */
15516 };
15517
15518 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
15519         /* output mixer control */
15520         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15521         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15522         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15523
15524         { } /* end */
15525 };
15526
15527 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
15528         /* output mixer control */
15529         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15530         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15531         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15532         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15533         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15534
15535         /* Input mixer control */
15536         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15537            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15538         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15539         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15540         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15541         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15542         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15543         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15544         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15545         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15546
15547         {
15548                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15549                 .name = "Channel Mode",
15550                 .info = alc_ch_mode_info,
15551                 .get = alc_ch_mode_get,
15552                 .put = alc_ch_mode_put,
15553                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
15554         },
15555         { } /* end */
15556 };
15557
15558 static struct snd_kcontrol_new alc861_asus_mixer[] = {
15559         /* output mixer control */
15560         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15561         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15562         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15563         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15564         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15565
15566         /* Input mixer control */
15567         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15568         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15569         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15570         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15571         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15572         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15573         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15574         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15575         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15576         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
15577
15578         {
15579                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15580                 .name = "Channel Mode",
15581                 .info = alc_ch_mode_info,
15582                 .get = alc_ch_mode_get,
15583                 .put = alc_ch_mode_put,
15584                 .private_value = ARRAY_SIZE(alc861_asus_modes),
15585         },
15586         { }
15587 };
15588
15589 /* additional mixer */
15590 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
15591         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15592         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15593         { }
15594 };
15595
15596 /*
15597  * generic initialization of ADC, input mixers and output mixers
15598  */
15599 static struct hda_verb alc861_base_init_verbs[] = {
15600         /*
15601          * Unmute ADC0 and set the default input to mic-in
15602          */
15603         /* port-A for surround (rear panel) */
15604         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15605         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
15606         /* port-B for mic-in (rear panel) with vref */
15607         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15608         /* port-C for line-in (rear panel) */
15609         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15610         /* port-D for Front */
15611         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15612         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15613         /* port-E for HP out (front panel) */
15614         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15615         /* route front PCM to HP */
15616         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15617         /* port-F for mic-in (front panel) with vref */
15618         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15619         /* port-G for CLFE (rear panel) */
15620         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15621         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15622         /* port-H for side (rear panel) */
15623         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15624         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
15625         /* CD-in */
15626         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15627         /* route front mic to ADC1*/
15628         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15629         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15630
15631         /* Unmute DAC0~3 & spdif out*/
15632         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15633         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15634         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15635         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15636         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15637
15638         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15639         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15640         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15641         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15642         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15643
15644         /* Unmute Stereo Mixer 15 */
15645         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15646         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15647         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15648         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15649
15650         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15651         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15652         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15653         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15654         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15655         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15656         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15657         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15658         /* hp used DAC 3 (Front) */
15659         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15660         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15661
15662         { }
15663 };
15664
15665 static struct hda_verb alc861_threestack_init_verbs[] = {
15666         /*
15667          * Unmute ADC0 and set the default input to mic-in
15668          */
15669         /* port-A for surround (rear panel) */
15670         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15671         /* port-B for mic-in (rear panel) with vref */
15672         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15673         /* port-C for line-in (rear panel) */
15674         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15675         /* port-D for Front */
15676         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15677         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15678         /* port-E for HP out (front panel) */
15679         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15680         /* route front PCM to HP */
15681         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15682         /* port-F for mic-in (front panel) with vref */
15683         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15684         /* port-G for CLFE (rear panel) */
15685         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15686         /* port-H for side (rear panel) */
15687         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15688         /* CD-in */
15689         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15690         /* route front mic to ADC1*/
15691         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15692         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15693         /* Unmute DAC0~3 & spdif out*/
15694         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15695         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15696         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15697         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15698         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15699
15700         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15701         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15702         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15703         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15704         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15705
15706         /* Unmute Stereo Mixer 15 */
15707         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15708         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15709         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15710         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15711
15712         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15713         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15714         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15715         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15716         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15717         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15718         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15719         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15720         /* hp used DAC 3 (Front) */
15721         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15722         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15723         { }
15724 };
15725
15726 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
15727         /*
15728          * Unmute ADC0 and set the default input to mic-in
15729          */
15730         /* port-A for surround (rear panel) */
15731         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15732         /* port-B for mic-in (rear panel) with vref */
15733         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15734         /* port-C for line-in (rear panel) */
15735         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15736         /* port-D for Front */
15737         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15738         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15739         /* port-E for HP out (front panel) */
15740         /* this has to be set to VREF80 */
15741         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15742         /* route front PCM to HP */
15743         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15744         /* port-F for mic-in (front panel) with vref */
15745         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15746         /* port-G for CLFE (rear panel) */
15747         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15748         /* port-H for side (rear panel) */
15749         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15750         /* CD-in */
15751         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15752         /* route front mic to ADC1*/
15753         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15754         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15755         /* Unmute DAC0~3 & spdif out*/
15756         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15757         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15758         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15759         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15760         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15761
15762         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15763         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15764         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15765         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15766         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15767
15768         /* Unmute Stereo Mixer 15 */
15769         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15770         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15771         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15772         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15773
15774         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15775         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15776         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15777         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15778         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15779         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15780         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15781         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15782         /* hp used DAC 3 (Front) */
15783         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15784         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15785         { }
15786 };
15787
15788 static struct hda_verb alc861_asus_init_verbs[] = {
15789         /*
15790          * Unmute ADC0 and set the default input to mic-in
15791          */
15792         /* port-A for surround (rear panel)
15793          * according to codec#0 this is the HP jack
15794          */
15795         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
15796         /* route front PCM to HP */
15797         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
15798         /* port-B for mic-in (rear panel) with vref */
15799         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15800         /* port-C for line-in (rear panel) */
15801         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15802         /* port-D for Front */
15803         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15804         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15805         /* port-E for HP out (front panel) */
15806         /* this has to be set to VREF80 */
15807         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15808         /* route front PCM to HP */
15809         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15810         /* port-F for mic-in (front panel) with vref */
15811         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15812         /* port-G for CLFE (rear panel) */
15813         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15814         /* port-H for side (rear panel) */
15815         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15816         /* CD-in */
15817         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15818         /* route front mic to ADC1*/
15819         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15820         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15821         /* Unmute DAC0~3 & spdif out*/
15822         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15823         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15824         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15825         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15826         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15827         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15828         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15829         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15830         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15831         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15832
15833         /* Unmute Stereo Mixer 15 */
15834         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15835         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15836         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15837         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15838
15839         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15840         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15841         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15842         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15843         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15844         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15845         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15846         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15847         /* hp used DAC 3 (Front) */
15848         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15849         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15850         { }
15851 };
15852
15853 /* additional init verbs for ASUS laptops */
15854 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
15855         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
15856         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
15857         { }
15858 };
15859
15860 /*
15861  * generic initialization of ADC, input mixers and output mixers
15862  */
15863 static struct hda_verb alc861_auto_init_verbs[] = {
15864         /*
15865          * Unmute ADC0 and set the default input to mic-in
15866          */
15867         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
15868         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15869
15870         /* Unmute DAC0~3 & spdif out*/
15871         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15872         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15873         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15874         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15875         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15876
15877         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15878         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15879         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15880         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15881         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15882
15883         /* Unmute Stereo Mixer 15 */
15884         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15885         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15886         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15887         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
15888
15889         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15890         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15891         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15892         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15893         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15894         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15895         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15896         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15897
15898         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15899         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15900         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15901         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15902         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15903         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15904         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15905         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15906
15907         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
15908
15909         { }
15910 };
15911
15912 static struct hda_verb alc861_toshiba_init_verbs[] = {
15913         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15914
15915         { }
15916 };
15917
15918 /* toggle speaker-output according to the hp-jack state */
15919 static void alc861_toshiba_automute(struct hda_codec *codec)
15920 {
15921         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
15922
15923         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
15924                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
15925         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
15926                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
15927 }
15928
15929 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
15930                                        unsigned int res)
15931 {
15932         if ((res >> 26) == ALC880_HP_EVENT)
15933                 alc861_toshiba_automute(codec);
15934 }
15935
15936 /* pcm configuration: identical with ALC880 */
15937 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
15938 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
15939 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
15940 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
15941
15942
15943 #define ALC861_DIGOUT_NID       0x07
15944
15945 static struct hda_channel_mode alc861_8ch_modes[1] = {
15946         { 8, NULL }
15947 };
15948
15949 static hda_nid_t alc861_dac_nids[4] = {
15950         /* front, surround, clfe, side */
15951         0x03, 0x06, 0x05, 0x04
15952 };
15953
15954 static hda_nid_t alc660_dac_nids[3] = {
15955         /* front, clfe, surround */
15956         0x03, 0x05, 0x06
15957 };
15958
15959 static hda_nid_t alc861_adc_nids[1] = {
15960         /* ADC0-2 */
15961         0x08,
15962 };
15963
15964 static struct hda_input_mux alc861_capture_source = {
15965         .num_items = 5,
15966         .items = {
15967                 { "Mic", 0x0 },
15968                 { "Front Mic", 0x3 },
15969                 { "Line", 0x1 },
15970                 { "CD", 0x4 },
15971                 { "Mixer", 0x5 },
15972         },
15973 };
15974
15975 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
15976 {
15977         struct alc_spec *spec = codec->spec;
15978         hda_nid_t mix, srcs[5];
15979         int i, j, num;
15980
15981         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
15982                 return 0;
15983         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15984         if (num < 0)
15985                 return 0;
15986         for (i = 0; i < num; i++) {
15987                 unsigned int type;
15988                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
15989                 if (type != AC_WID_AUD_OUT)
15990                         continue;
15991                 for (j = 0; j < spec->multiout.num_dacs; j++)
15992                         if (spec->multiout.dac_nids[j] == srcs[i])
15993                                 break;
15994                 if (j >= spec->multiout.num_dacs)
15995                         return srcs[i];
15996         }
15997         return 0;
15998 }
15999
16000 /* fill in the dac_nids table from the parsed pin configuration */
16001 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
16002                                      const struct auto_pin_cfg *cfg)
16003 {
16004         struct alc_spec *spec = codec->spec;
16005         int i;
16006         hda_nid_t nid, dac;
16007
16008         spec->multiout.dac_nids = spec->private_dac_nids;
16009         for (i = 0; i < cfg->line_outs; i++) {
16010                 nid = cfg->line_out_pins[i];
16011                 dac = alc861_look_for_dac(codec, nid);
16012                 if (!dac)
16013                         continue;
16014                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
16015         }
16016         return 0;
16017 }
16018
16019 static int __alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
16020                                   hda_nid_t nid, int idx, unsigned int chs)
16021 {
16022         return __add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
16023                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
16024 }
16025
16026 #define alc861_create_out_sw(codec, pfx, nid, chs) \
16027         __alc861_create_out_sw(codec, pfx, nid, 0, chs)
16028
16029 /* add playback controls from the parsed DAC table */
16030 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
16031                                              const struct auto_pin_cfg *cfg)
16032 {
16033         struct alc_spec *spec = codec->spec;
16034         static const char * const chname[4] = {
16035                 "Front", "Surround", NULL /*CLFE*/, "Side"
16036         };
16037         const char *pfx = alc_get_line_out_pfx(cfg, true);
16038         hda_nid_t nid;
16039         int i, err;
16040
16041         for (i = 0; i < cfg->line_outs; i++) {
16042                 nid = spec->multiout.dac_nids[i];
16043                 if (!nid)
16044                         continue;
16045                 if (!pfx && i == 2) {
16046                         /* Center/LFE */
16047                         err = alc861_create_out_sw(codec, "Center", nid, 1);
16048                         if (err < 0)
16049                                 return err;
16050                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
16051                         if (err < 0)
16052                                 return err;
16053                 } else {
16054                         const char *name = pfx;
16055                         if (!name)
16056                                 name = chname[i];
16057                         err = __alc861_create_out_sw(codec, name, nid, i, 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 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 = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
16184         if (err < 0)
16185                 return err;
16186         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
16187         if (err < 0)
16188                 return err;
16189         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
16190         if (err < 0)
16191                 return err;
16192
16193         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16194
16195         alc_auto_parse_digital(codec);
16196
16197         if (spec->kctls.list)
16198                 add_mixer(spec, spec->kctls.list);
16199
16200         add_verb(spec, alc861_auto_init_verbs);
16201
16202         spec->num_mux_defs = 1;
16203         spec->input_mux = &spec->private_imux[0];
16204
16205         spec->adc_nids = alc861_adc_nids;
16206         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
16207         set_capture_mixer(codec);
16208
16209         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
16210
16211         return 1;
16212 }
16213
16214 /* additional initialization for auto-configuration model */
16215 static void alc861_auto_init(struct hda_codec *codec)
16216 {
16217         struct alc_spec *spec = codec->spec;
16218         alc861_auto_init_multi_out(codec);
16219         alc861_auto_init_hp_out(codec);
16220         alc861_auto_init_analog_input(codec);
16221         alc_auto_init_digital(codec);
16222         if (spec->unsol_event)
16223                 alc_inithook(codec);
16224 }
16225
16226 #ifdef CONFIG_SND_HDA_POWER_SAVE
16227 static struct hda_amp_list alc861_loopbacks[] = {
16228         { 0x15, HDA_INPUT, 0 },
16229         { 0x15, HDA_INPUT, 1 },
16230         { 0x15, HDA_INPUT, 2 },
16231         { 0x15, HDA_INPUT, 3 },
16232         { } /* end */
16233 };
16234 #endif
16235
16236
16237 /*
16238  * configuration and preset
16239  */
16240 static const char * const alc861_models[ALC861_MODEL_LAST] = {
16241         [ALC861_3ST]            = "3stack",
16242         [ALC660_3ST]            = "3stack-660",
16243         [ALC861_3ST_DIG]        = "3stack-dig",
16244         [ALC861_6ST_DIG]        = "6stack-dig",
16245         [ALC861_UNIWILL_M31]    = "uniwill-m31",
16246         [ALC861_TOSHIBA]        = "toshiba",
16247         [ALC861_ASUS]           = "asus",
16248         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
16249         [ALC861_AUTO]           = "auto",
16250 };
16251
16252 static struct snd_pci_quirk alc861_cfg_tbl[] = {
16253         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
16254         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16255         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16256         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
16257         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
16258         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
16259         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
16260         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
16261          *        Any other models that need this preset?
16262          */
16263         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
16264         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
16265         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
16266         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
16267         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
16268         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
16269         /* FIXME: the below seems conflict */
16270         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
16271         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
16272         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
16273         {}
16274 };
16275
16276 static struct alc_config_preset alc861_presets[] = {
16277         [ALC861_3ST] = {
16278                 .mixers = { alc861_3ST_mixer },
16279                 .init_verbs = { alc861_threestack_init_verbs },
16280                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16281                 .dac_nids = alc861_dac_nids,
16282                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16283                 .channel_mode = alc861_threestack_modes,
16284                 .need_dac_fix = 1,
16285                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16286                 .adc_nids = alc861_adc_nids,
16287                 .input_mux = &alc861_capture_source,
16288         },
16289         [ALC861_3ST_DIG] = {
16290                 .mixers = { alc861_base_mixer },
16291                 .init_verbs = { alc861_threestack_init_verbs },
16292                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16293                 .dac_nids = alc861_dac_nids,
16294                 .dig_out_nid = ALC861_DIGOUT_NID,
16295                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16296                 .channel_mode = alc861_threestack_modes,
16297                 .need_dac_fix = 1,
16298                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16299                 .adc_nids = alc861_adc_nids,
16300                 .input_mux = &alc861_capture_source,
16301         },
16302         [ALC861_6ST_DIG] = {
16303                 .mixers = { alc861_base_mixer },
16304                 .init_verbs = { alc861_base_init_verbs },
16305                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16306                 .dac_nids = alc861_dac_nids,
16307                 .dig_out_nid = ALC861_DIGOUT_NID,
16308                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
16309                 .channel_mode = alc861_8ch_modes,
16310                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16311                 .adc_nids = alc861_adc_nids,
16312                 .input_mux = &alc861_capture_source,
16313         },
16314         [ALC660_3ST] = {
16315                 .mixers = { alc861_3ST_mixer },
16316                 .init_verbs = { alc861_threestack_init_verbs },
16317                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
16318                 .dac_nids = alc660_dac_nids,
16319                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16320                 .channel_mode = alc861_threestack_modes,
16321                 .need_dac_fix = 1,
16322                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16323                 .adc_nids = alc861_adc_nids,
16324                 .input_mux = &alc861_capture_source,
16325         },
16326         [ALC861_UNIWILL_M31] = {
16327                 .mixers = { alc861_uniwill_m31_mixer },
16328                 .init_verbs = { alc861_uniwill_m31_init_verbs },
16329                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16330                 .dac_nids = alc861_dac_nids,
16331                 .dig_out_nid = ALC861_DIGOUT_NID,
16332                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
16333                 .channel_mode = alc861_uniwill_m31_modes,
16334                 .need_dac_fix = 1,
16335                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16336                 .adc_nids = alc861_adc_nids,
16337                 .input_mux = &alc861_capture_source,
16338         },
16339         [ALC861_TOSHIBA] = {
16340                 .mixers = { alc861_toshiba_mixer },
16341                 .init_verbs = { alc861_base_init_verbs,
16342                                 alc861_toshiba_init_verbs },
16343                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16344                 .dac_nids = alc861_dac_nids,
16345                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16346                 .channel_mode = alc883_3ST_2ch_modes,
16347                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16348                 .adc_nids = alc861_adc_nids,
16349                 .input_mux = &alc861_capture_source,
16350                 .unsol_event = alc861_toshiba_unsol_event,
16351                 .init_hook = alc861_toshiba_automute,
16352         },
16353         [ALC861_ASUS] = {
16354                 .mixers = { alc861_asus_mixer },
16355                 .init_verbs = { alc861_asus_init_verbs },
16356                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16357                 .dac_nids = alc861_dac_nids,
16358                 .dig_out_nid = ALC861_DIGOUT_NID,
16359                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
16360                 .channel_mode = alc861_asus_modes,
16361                 .need_dac_fix = 1,
16362                 .hp_nid = 0x06,
16363                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16364                 .adc_nids = alc861_adc_nids,
16365                 .input_mux = &alc861_capture_source,
16366         },
16367         [ALC861_ASUS_LAPTOP] = {
16368                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
16369                 .init_verbs = { alc861_asus_init_verbs,
16370                                 alc861_asus_laptop_init_verbs },
16371                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16372                 .dac_nids = alc861_dac_nids,
16373                 .dig_out_nid = ALC861_DIGOUT_NID,
16374                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16375                 .channel_mode = alc883_3ST_2ch_modes,
16376                 .need_dac_fix = 1,
16377                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16378                 .adc_nids = alc861_adc_nids,
16379                 .input_mux = &alc861_capture_source,
16380         },
16381 };
16382
16383 /* Pin config fixes */
16384 enum {
16385         PINFIX_FSC_AMILO_PI1505,
16386 };
16387
16388 static const struct alc_fixup alc861_fixups[] = {
16389         [PINFIX_FSC_AMILO_PI1505] = {
16390                 .type = ALC_FIXUP_PINS,
16391                 .v.pins = (const struct alc_pincfg[]) {
16392                         { 0x0b, 0x0221101f }, /* HP */
16393                         { 0x0f, 0x90170310 }, /* speaker */
16394                         { }
16395                 }
16396         },
16397 };
16398
16399 static struct snd_pci_quirk alc861_fixup_tbl[] = {
16400         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
16401         {}
16402 };
16403
16404 static int patch_alc861(struct hda_codec *codec)
16405 {
16406         struct alc_spec *spec;
16407         int board_config;
16408         int err;
16409
16410         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16411         if (spec == NULL)
16412                 return -ENOMEM;
16413
16414         codec->spec = spec;
16415
16416         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
16417                                                   alc861_models,
16418                                                   alc861_cfg_tbl);
16419
16420         if (board_config < 0) {
16421                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16422                        codec->chip_name);
16423                 board_config = ALC861_AUTO;
16424         }
16425
16426         if (board_config == ALC861_AUTO) {
16427                 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
16428                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
16429         }
16430
16431         if (board_config == ALC861_AUTO) {
16432                 /* automatic parse from the BIOS config */
16433                 err = alc861_parse_auto_config(codec);
16434                 if (err < 0) {
16435                         alc_free(codec);
16436                         return err;
16437                 } else if (!err) {
16438                         printk(KERN_INFO
16439                                "hda_codec: Cannot set up configuration "
16440                                "from BIOS.  Using base mode...\n");
16441                    board_config = ALC861_3ST_DIG;
16442                 }
16443         }
16444
16445         err = snd_hda_attach_beep_device(codec, 0x23);
16446         if (err < 0) {
16447                 alc_free(codec);
16448                 return err;
16449         }
16450
16451         if (board_config != ALC861_AUTO)
16452                 setup_preset(codec, &alc861_presets[board_config]);
16453
16454         spec->stream_analog_playback = &alc861_pcm_analog_playback;
16455         spec->stream_analog_capture = &alc861_pcm_analog_capture;
16456
16457         spec->stream_digital_playback = &alc861_pcm_digital_playback;
16458         spec->stream_digital_capture = &alc861_pcm_digital_capture;
16459
16460         if (!spec->cap_mixer)
16461                 set_capture_mixer(codec);
16462         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
16463
16464         spec->vmaster_nid = 0x03;
16465
16466         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
16467
16468         codec->patch_ops = alc_patch_ops;
16469         if (board_config == ALC861_AUTO) {
16470                 spec->init_hook = alc861_auto_init;
16471 #ifdef CONFIG_SND_HDA_POWER_SAVE
16472                 spec->power_hook = alc_power_eapd;
16473 #endif
16474         }
16475 #ifdef CONFIG_SND_HDA_POWER_SAVE
16476         if (!spec->loopback.amplist)
16477                 spec->loopback.amplist = alc861_loopbacks;
16478 #endif
16479
16480         return 0;
16481 }
16482
16483 /*
16484  * ALC861-VD support
16485  *
16486  * Based on ALC882
16487  *
16488  * In addition, an independent DAC
16489  */
16490 #define ALC861VD_DIGOUT_NID     0x06
16491
16492 static hda_nid_t alc861vd_dac_nids[4] = {
16493         /* front, surr, clfe, side surr */
16494         0x02, 0x03, 0x04, 0x05
16495 };
16496
16497 /* dac_nids for ALC660vd are in a different order - according to
16498  * Realtek's driver.
16499  * This should probably result in a different mixer for 6stack models
16500  * of ALC660vd codecs, but for now there is only 3stack mixer
16501  * - and it is the same as in 861vd.
16502  * adc_nids in ALC660vd are (is) the same as in 861vd
16503  */
16504 static hda_nid_t alc660vd_dac_nids[3] = {
16505         /* front, rear, clfe, rear_surr */
16506         0x02, 0x04, 0x03
16507 };
16508
16509 static hda_nid_t alc861vd_adc_nids[1] = {
16510         /* ADC0 */
16511         0x09,
16512 };
16513
16514 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
16515
16516 /* input MUX */
16517 /* FIXME: should be a matrix-type input source selection */
16518 static struct hda_input_mux alc861vd_capture_source = {
16519         .num_items = 4,
16520         .items = {
16521                 { "Mic", 0x0 },
16522                 { "Front Mic", 0x1 },
16523                 { "Line", 0x2 },
16524                 { "CD", 0x4 },
16525         },
16526 };
16527
16528 static struct hda_input_mux alc861vd_dallas_capture_source = {
16529         .num_items = 2,
16530         .items = {
16531                 { "Mic", 0x0 },
16532                 { "Internal Mic", 0x1 },
16533         },
16534 };
16535
16536 static struct hda_input_mux alc861vd_hp_capture_source = {
16537         .num_items = 2,
16538         .items = {
16539                 { "Front Mic", 0x0 },
16540                 { "ATAPI Mic", 0x1 },
16541         },
16542 };
16543
16544 /*
16545  * 2ch mode
16546  */
16547 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
16548         { 2, NULL }
16549 };
16550
16551 /*
16552  * 6ch mode
16553  */
16554 static struct hda_verb alc861vd_6stack_ch6_init[] = {
16555         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16556         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16557         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16558         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16559         { } /* end */
16560 };
16561
16562 /*
16563  * 8ch mode
16564  */
16565 static struct hda_verb alc861vd_6stack_ch8_init[] = {
16566         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16567         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16568         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16569         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16570         { } /* end */
16571 };
16572
16573 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
16574         { 6, alc861vd_6stack_ch6_init },
16575         { 8, alc861vd_6stack_ch8_init },
16576 };
16577
16578 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
16579         {
16580                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16581                 .name = "Channel Mode",
16582                 .info = alc_ch_mode_info,
16583                 .get = alc_ch_mode_get,
16584                 .put = alc_ch_mode_put,
16585         },
16586         { } /* end */
16587 };
16588
16589 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16590  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16591  */
16592 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
16593         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16594         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16595
16596         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16597         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
16598
16599         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
16600                                 HDA_OUTPUT),
16601         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
16602                                 HDA_OUTPUT),
16603         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
16604         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
16605
16606         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
16607         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
16608
16609         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16610
16611         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16612         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16613         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16614
16615         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16616         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16617         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16618
16619         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16620         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16621
16622         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16623         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16624
16625         { } /* end */
16626 };
16627
16628 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
16629         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16630         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16631
16632         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16633
16634         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16635         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16636         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16637
16638         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16639         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16640         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16641
16642         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16643         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16644
16645         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16646         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16647
16648         { } /* end */
16649 };
16650
16651 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
16652         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16653         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
16654         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16655
16656         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16657
16658         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16659         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16660         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16661
16662         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16663         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16664         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16665
16666         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16667         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16668
16669         { } /* end */
16670 };
16671
16672 /* Pin assignment: Speaker=0x14, HP = 0x15,
16673  *                 Mic=0x18, Internal Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
16674  */
16675 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
16676         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16677         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
16678         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16679         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16680         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16681         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16682         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16683         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
16684         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16685         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16686         { } /* end */
16687 };
16688
16689 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
16690  *                 Front Mic=0x18, ATAPI Mic = 0x19,
16691  */
16692 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
16693         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16694         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16695         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16696         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16697         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16698         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16699         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16700         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16701
16702         { } /* end */
16703 };
16704
16705 /*
16706  * generic initialization of ADC, input mixers and output mixers
16707  */
16708 static struct hda_verb alc861vd_volume_init_verbs[] = {
16709         /*
16710          * Unmute ADC0 and set the default input to mic-in
16711          */
16712         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16713         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16714
16715         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
16716          * the analog-loopback mixer widget
16717          */
16718         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16719         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16720         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16721         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16722         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16723         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16724
16725         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
16726         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16727         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16728         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
16729         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
16730
16731         /*
16732          * Set up output mixers (0x02 - 0x05)
16733          */
16734         /* set vol=0 to output mixers */
16735         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16736         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16737         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16738         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16739
16740         /* set up input amps for analog loopback */
16741         /* Amp Indices: DAC = 0, mixer = 1 */
16742         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16743         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16744         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16745         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16746         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16747         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16748         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16749         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16750
16751         { }
16752 };
16753
16754 /*
16755  * 3-stack pin configuration:
16756  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
16757  */
16758 static struct hda_verb alc861vd_3stack_init_verbs[] = {
16759         /*
16760          * Set pin mode and muting
16761          */
16762         /* set front pin widgets 0x14 for output */
16763         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16764         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16765         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16766
16767         /* Mic (rear) pin: input vref at 80% */
16768         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16769         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16770         /* Front Mic pin: input vref at 80% */
16771         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16772         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16773         /* Line In pin: input */
16774         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16775         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16776         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16777         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16778         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16779         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16780         /* CD pin widget for input */
16781         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16782
16783         { }
16784 };
16785
16786 /*
16787  * 6-stack pin configuration:
16788  */
16789 static struct hda_verb alc861vd_6stack_init_verbs[] = {
16790         /*
16791          * Set pin mode and muting
16792          */
16793         /* set front pin widgets 0x14 for output */
16794         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16795         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16796         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16797
16798         /* Rear Pin: output 1 (0x0d) */
16799         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16800         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16801         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16802         /* CLFE Pin: output 2 (0x0e) */
16803         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16804         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16805         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
16806         /* Side Pin: output 3 (0x0f) */
16807         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16808         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16809         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
16810
16811         /* Mic (rear) pin: input vref at 80% */
16812         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16813         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16814         /* Front Mic pin: input vref at 80% */
16815         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16816         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16817         /* Line In pin: input */
16818         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16819         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16820         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16821         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16822         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16823         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16824         /* CD pin widget for input */
16825         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16826
16827         { }
16828 };
16829
16830 static struct hda_verb alc861vd_eapd_verbs[] = {
16831         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16832         { }
16833 };
16834
16835 static struct hda_verb alc660vd_eapd_verbs[] = {
16836         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16837         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16838         { }
16839 };
16840
16841 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
16842         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16843         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16844         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
16845         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16846         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16847         {}
16848 };
16849
16850 static void alc861vd_lenovo_setup(struct hda_codec *codec)
16851 {
16852         struct alc_spec *spec = codec->spec;
16853         spec->autocfg.hp_pins[0] = 0x1b;
16854         spec->autocfg.speaker_pins[0] = 0x14;
16855 }
16856
16857 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
16858 {
16859         alc_automute_amp(codec);
16860         alc88x_simple_mic_automute(codec);
16861 }
16862
16863 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
16864                                         unsigned int res)
16865 {
16866         switch (res >> 26) {
16867         case ALC880_MIC_EVENT:
16868                 alc88x_simple_mic_automute(codec);
16869                 break;
16870         default:
16871                 alc_automute_amp_unsol_event(codec, res);
16872                 break;
16873         }
16874 }
16875
16876 static struct hda_verb alc861vd_dallas_verbs[] = {
16877         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16878         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16879         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16880         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16881
16882         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16883         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16884         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16885         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16886         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16887         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16888         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16889         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16890
16891         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16892         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16893         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16894         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16895         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16896         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16897         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16898         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16899
16900         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16901         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16902         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16903         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16904         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16905         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16906         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16907         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16908
16909         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16910         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16911         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16912         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16913
16914         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16915         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16916         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16917
16918         { } /* end */
16919 };
16920
16921 /* toggle speaker-output according to the hp-jack state */
16922 static void alc861vd_dallas_setup(struct hda_codec *codec)
16923 {
16924         struct alc_spec *spec = codec->spec;
16925
16926         spec->autocfg.hp_pins[0] = 0x15;
16927         spec->autocfg.speaker_pins[0] = 0x14;
16928 }
16929
16930 #ifdef CONFIG_SND_HDA_POWER_SAVE
16931 #define alc861vd_loopbacks      alc880_loopbacks
16932 #endif
16933
16934 /* pcm configuration: identical with ALC880 */
16935 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
16936 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
16937 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
16938 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
16939
16940 /*
16941  * configuration and preset
16942  */
16943 static const char * const alc861vd_models[ALC861VD_MODEL_LAST] = {
16944         [ALC660VD_3ST]          = "3stack-660",
16945         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
16946         [ALC660VD_ASUS_V1S]     = "asus-v1s",
16947         [ALC861VD_3ST]          = "3stack",
16948         [ALC861VD_3ST_DIG]      = "3stack-digout",
16949         [ALC861VD_6ST_DIG]      = "6stack-digout",
16950         [ALC861VD_LENOVO]       = "lenovo",
16951         [ALC861VD_DALLAS]       = "dallas",
16952         [ALC861VD_HP]           = "hp",
16953         [ALC861VD_AUTO]         = "auto",
16954 };
16955
16956 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
16957         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
16958         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
16959         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
16960         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
16961         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
16962         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
16963         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
16964         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
16965         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
16966         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
16967         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
16968         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
16969         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
16970         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
16971         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
16972         {}
16973 };
16974
16975 static struct alc_config_preset alc861vd_presets[] = {
16976         [ALC660VD_3ST] = {
16977                 .mixers = { alc861vd_3st_mixer },
16978                 .init_verbs = { alc861vd_volume_init_verbs,
16979                                  alc861vd_3stack_init_verbs },
16980                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16981                 .dac_nids = alc660vd_dac_nids,
16982                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16983                 .channel_mode = alc861vd_3stack_2ch_modes,
16984                 .input_mux = &alc861vd_capture_source,
16985         },
16986         [ALC660VD_3ST_DIG] = {
16987                 .mixers = { alc861vd_3st_mixer },
16988                 .init_verbs = { alc861vd_volume_init_verbs,
16989                                  alc861vd_3stack_init_verbs },
16990                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16991                 .dac_nids = alc660vd_dac_nids,
16992                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16993                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16994                 .channel_mode = alc861vd_3stack_2ch_modes,
16995                 .input_mux = &alc861vd_capture_source,
16996         },
16997         [ALC861VD_3ST] = {
16998                 .mixers = { alc861vd_3st_mixer },
16999                 .init_verbs = { alc861vd_volume_init_verbs,
17000                                  alc861vd_3stack_init_verbs },
17001                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17002                 .dac_nids = alc861vd_dac_nids,
17003                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17004                 .channel_mode = alc861vd_3stack_2ch_modes,
17005                 .input_mux = &alc861vd_capture_source,
17006         },
17007         [ALC861VD_3ST_DIG] = {
17008                 .mixers = { alc861vd_3st_mixer },
17009                 .init_verbs = { alc861vd_volume_init_verbs,
17010                                  alc861vd_3stack_init_verbs },
17011                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17012                 .dac_nids = alc861vd_dac_nids,
17013                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17014                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17015                 .channel_mode = alc861vd_3stack_2ch_modes,
17016                 .input_mux = &alc861vd_capture_source,
17017         },
17018         [ALC861VD_6ST_DIG] = {
17019                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
17020                 .init_verbs = { alc861vd_volume_init_verbs,
17021                                 alc861vd_6stack_init_verbs },
17022                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17023                 .dac_nids = alc861vd_dac_nids,
17024                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17025                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
17026                 .channel_mode = alc861vd_6stack_modes,
17027                 .input_mux = &alc861vd_capture_source,
17028         },
17029         [ALC861VD_LENOVO] = {
17030                 .mixers = { alc861vd_lenovo_mixer },
17031                 .init_verbs = { alc861vd_volume_init_verbs,
17032                                 alc861vd_3stack_init_verbs,
17033                                 alc861vd_eapd_verbs,
17034                                 alc861vd_lenovo_unsol_verbs },
17035                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
17036                 .dac_nids = alc660vd_dac_nids,
17037                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17038                 .channel_mode = alc861vd_3stack_2ch_modes,
17039                 .input_mux = &alc861vd_capture_source,
17040                 .unsol_event = alc861vd_lenovo_unsol_event,
17041                 .setup = alc861vd_lenovo_setup,
17042                 .init_hook = alc861vd_lenovo_init_hook,
17043         },
17044         [ALC861VD_DALLAS] = {
17045                 .mixers = { alc861vd_dallas_mixer },
17046                 .init_verbs = { alc861vd_dallas_verbs },
17047                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17048                 .dac_nids = alc861vd_dac_nids,
17049                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17050                 .channel_mode = alc861vd_3stack_2ch_modes,
17051                 .input_mux = &alc861vd_dallas_capture_source,
17052                 .unsol_event = alc_automute_amp_unsol_event,
17053                 .setup = alc861vd_dallas_setup,
17054                 .init_hook = alc_automute_amp,
17055         },
17056         [ALC861VD_HP] = {
17057                 .mixers = { alc861vd_hp_mixer },
17058                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
17059                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17060                 .dac_nids = alc861vd_dac_nids,
17061                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17062                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17063                 .channel_mode = alc861vd_3stack_2ch_modes,
17064                 .input_mux = &alc861vd_hp_capture_source,
17065                 .unsol_event = alc_automute_amp_unsol_event,
17066                 .setup = alc861vd_dallas_setup,
17067                 .init_hook = alc_automute_amp,
17068         },
17069         [ALC660VD_ASUS_V1S] = {
17070                 .mixers = { alc861vd_lenovo_mixer },
17071                 .init_verbs = { alc861vd_volume_init_verbs,
17072                                 alc861vd_3stack_init_verbs,
17073                                 alc861vd_eapd_verbs,
17074                                 alc861vd_lenovo_unsol_verbs },
17075                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
17076                 .dac_nids = alc660vd_dac_nids,
17077                 .dig_out_nid = ALC861VD_DIGOUT_NID,
17078                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17079                 .channel_mode = alc861vd_3stack_2ch_modes,
17080                 .input_mux = &alc861vd_capture_source,
17081                 .unsol_event = alc861vd_lenovo_unsol_event,
17082                 .setup = alc861vd_lenovo_setup,
17083                 .init_hook = alc861vd_lenovo_init_hook,
17084         },
17085 };
17086
17087 /*
17088  * BIOS auto configuration
17089  */
17090 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
17091                                                 const struct auto_pin_cfg *cfg)
17092 {
17093         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x22, 0);
17094 }
17095
17096
17097 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
17098                                 hda_nid_t nid, int pin_type, int dac_idx)
17099 {
17100         alc_set_pin_output(codec, nid, pin_type);
17101 }
17102
17103 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
17104 {
17105         struct alc_spec *spec = codec->spec;
17106         int i;
17107
17108         for (i = 0; i <= HDA_SIDE; i++) {
17109                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
17110                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
17111                 if (nid)
17112                         alc861vd_auto_set_output_and_unmute(codec, nid,
17113                                                             pin_type, i);
17114         }
17115 }
17116
17117
17118 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
17119 {
17120         struct alc_spec *spec = codec->spec;
17121         hda_nid_t pin;
17122
17123         pin = spec->autocfg.hp_pins[0];
17124         if (pin) /* connect to front and use dac 0 */
17125                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
17126         pin = spec->autocfg.speaker_pins[0];
17127         if (pin)
17128                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
17129 }
17130
17131 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
17132
17133 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
17134 {
17135         struct alc_spec *spec = codec->spec;
17136         struct auto_pin_cfg *cfg = &spec->autocfg;
17137         int i;
17138
17139         for (i = 0; i < cfg->num_inputs; i++) {
17140                 hda_nid_t nid = cfg->inputs[i].pin;
17141                 if (alc_is_input_pin(codec, nid)) {
17142                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
17143                         if (nid != ALC861VD_PIN_CD_NID &&
17144                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17145                                 snd_hda_codec_write(codec, nid, 0,
17146                                                 AC_VERB_SET_AMP_GAIN_MUTE,
17147                                                 AMP_OUT_MUTE);
17148                 }
17149         }
17150 }
17151
17152 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
17153
17154 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
17155 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
17156
17157 /* add playback controls from the parsed DAC table */
17158 /* Based on ALC880 version. But ALC861VD has separate,
17159  * different NIDs for mute/unmute switch and volume control */
17160 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
17161                                              const struct auto_pin_cfg *cfg)
17162 {
17163         static const char * const chname[4] = {
17164                 "Front", "Surround", "CLFE", "Side"
17165         };
17166         const char *pfx = alc_get_line_out_pfx(cfg, true);
17167         hda_nid_t nid_v, nid_s;
17168         int i, err;
17169
17170         for (i = 0; i < cfg->line_outs; i++) {
17171                 if (!spec->multiout.dac_nids[i])
17172                         continue;
17173                 nid_v = alc861vd_idx_to_mixer_vol(
17174                                 alc880_dac_to_idx(
17175                                         spec->multiout.dac_nids[i]));
17176                 nid_s = alc861vd_idx_to_mixer_switch(
17177                                 alc880_dac_to_idx(
17178                                         spec->multiout.dac_nids[i]));
17179
17180                 if (!pfx && i == 2) {
17181                         /* Center/LFE */
17182                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17183                                               "Center",
17184                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
17185                                                               HDA_OUTPUT));
17186                         if (err < 0)
17187                                 return err;
17188                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17189                                               "LFE",
17190                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
17191                                                               HDA_OUTPUT));
17192                         if (err < 0)
17193                                 return err;
17194                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17195                                              "Center",
17196                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
17197                                                               HDA_INPUT));
17198                         if (err < 0)
17199                                 return err;
17200                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17201                                              "LFE",
17202                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
17203                                                               HDA_INPUT));
17204                         if (err < 0)
17205                                 return err;
17206                 } else {
17207                         const char *name = pfx;
17208                         if (!name)
17209                                 name = chname[i];
17210                         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17211                                                 name, i,
17212                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
17213                                                               HDA_OUTPUT));
17214                         if (err < 0)
17215                                 return err;
17216                         err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17217                                                name, i,
17218                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
17219                                                               HDA_INPUT));
17220                         if (err < 0)
17221                                 return err;
17222                 }
17223         }
17224         return 0;
17225 }
17226
17227 /* add playback controls for speaker and HP outputs */
17228 /* Based on ALC880 version. But ALC861VD has separate,
17229  * different NIDs for mute/unmute switch and volume control */
17230 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
17231                                         hda_nid_t pin, const char *pfx)
17232 {
17233         hda_nid_t nid_v, nid_s;
17234         int err;
17235
17236         if (!pin)
17237                 return 0;
17238
17239         if (alc880_is_fixed_pin(pin)) {
17240                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
17241                 /* specify the DAC as the extra output */
17242                 if (!spec->multiout.hp_nid)
17243                         spec->multiout.hp_nid = nid_v;
17244                 else
17245                         spec->multiout.extra_out_nid[0] = nid_v;
17246                 /* control HP volume/switch on the output mixer amp */
17247                 nid_v = alc861vd_idx_to_mixer_vol(
17248                                 alc880_fixed_pin_idx(pin));
17249                 nid_s = alc861vd_idx_to_mixer_switch(
17250                                 alc880_fixed_pin_idx(pin));
17251
17252                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17253                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
17254                 if (err < 0)
17255                         return err;
17256                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17257                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
17258                 if (err < 0)
17259                         return err;
17260         } else if (alc880_is_multi_pin(pin)) {
17261                 /* set manual connection */
17262                 /* we have only a switch on HP-out PIN */
17263                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17264                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17265                 if (err < 0)
17266                         return err;
17267         }
17268         return 0;
17269 }
17270
17271 /* parse the BIOS configuration and set up the alc_spec
17272  * return 1 if successful, 0 if the proper config is not found,
17273  * or a negative error code
17274  * Based on ALC880 version - had to change it to override
17275  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
17276 static int alc861vd_parse_auto_config(struct hda_codec *codec)
17277 {
17278         struct alc_spec *spec = codec->spec;
17279         int err;
17280         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
17281
17282         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17283                                            alc861vd_ignore);
17284         if (err < 0)
17285                 return err;
17286         if (!spec->autocfg.line_outs)
17287                 return 0; /* can't find valid BIOS pin config */
17288
17289         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17290         if (err < 0)
17291                 return err;
17292         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
17293         if (err < 0)
17294                 return err;
17295         err = alc861vd_auto_create_extra_out(spec,
17296                                              spec->autocfg.speaker_pins[0],
17297                                              "Speaker");
17298         if (err < 0)
17299                 return err;
17300         err = alc861vd_auto_create_extra_out(spec,
17301                                              spec->autocfg.hp_pins[0],
17302                                              "Headphone");
17303         if (err < 0)
17304                 return err;
17305         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
17306         if (err < 0)
17307                 return err;
17308
17309         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17310
17311         alc_auto_parse_digital(codec);
17312
17313         if (spec->kctls.list)
17314                 add_mixer(spec, spec->kctls.list);
17315
17316         add_verb(spec, alc861vd_volume_init_verbs);
17317
17318         spec->num_mux_defs = 1;
17319         spec->input_mux = &spec->private_imux[0];
17320
17321         err = alc_auto_add_mic_boost(codec);
17322         if (err < 0)
17323                 return err;
17324
17325         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
17326
17327         return 1;
17328 }
17329
17330 /* additional initialization for auto-configuration model */
17331 static void alc861vd_auto_init(struct hda_codec *codec)
17332 {
17333         struct alc_spec *spec = codec->spec;
17334         alc861vd_auto_init_multi_out(codec);
17335         alc861vd_auto_init_hp_out(codec);
17336         alc861vd_auto_init_analog_input(codec);
17337         alc861vd_auto_init_input_src(codec);
17338         alc_auto_init_digital(codec);
17339         if (spec->unsol_event)
17340                 alc_inithook(codec);
17341 }
17342
17343 enum {
17344         ALC660VD_FIX_ASUS_GPIO1
17345 };
17346
17347 /* reset GPIO1 */
17348 static const struct alc_fixup alc861vd_fixups[] = {
17349         [ALC660VD_FIX_ASUS_GPIO1] = {
17350                 .type = ALC_FIXUP_VERBS,
17351                 .v.verbs = (const struct hda_verb[]) {
17352                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
17353                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
17354                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
17355                         { }
17356                 }
17357         },
17358 };
17359
17360 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
17361         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
17362         {}
17363 };
17364
17365 static int patch_alc861vd(struct hda_codec *codec)
17366 {
17367         struct alc_spec *spec;
17368         int err, board_config;
17369
17370         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17371         if (spec == NULL)
17372                 return -ENOMEM;
17373
17374         codec->spec = spec;
17375
17376         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
17377                                                   alc861vd_models,
17378                                                   alc861vd_cfg_tbl);
17379
17380         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
17381                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17382                        codec->chip_name);
17383                 board_config = ALC861VD_AUTO;
17384         }
17385
17386         if (board_config == ALC861VD_AUTO) {
17387                 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
17388                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
17389         }
17390
17391         if (board_config == ALC861VD_AUTO) {
17392                 /* automatic parse from the BIOS config */
17393                 err = alc861vd_parse_auto_config(codec);
17394                 if (err < 0) {
17395                         alc_free(codec);
17396                         return err;
17397                 } else if (!err) {
17398                         printk(KERN_INFO
17399                                "hda_codec: Cannot set up configuration "
17400                                "from BIOS.  Using base mode...\n");
17401                         board_config = ALC861VD_3ST;
17402                 }
17403         }
17404
17405         err = snd_hda_attach_beep_device(codec, 0x23);
17406         if (err < 0) {
17407                 alc_free(codec);
17408                 return err;
17409         }
17410
17411         if (board_config != ALC861VD_AUTO)
17412                 setup_preset(codec, &alc861vd_presets[board_config]);
17413
17414         if (codec->vendor_id == 0x10ec0660) {
17415                 /* always turn on EAPD */
17416                 add_verb(spec, alc660vd_eapd_verbs);
17417         }
17418
17419         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
17420         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
17421
17422         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
17423         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
17424
17425         if (!spec->adc_nids) {
17426                 spec->adc_nids = alc861vd_adc_nids;
17427                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
17428         }
17429         if (!spec->capsrc_nids)
17430                 spec->capsrc_nids = alc861vd_capsrc_nids;
17431
17432         set_capture_mixer(codec);
17433         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17434
17435         spec->vmaster_nid = 0x02;
17436
17437         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
17438
17439         codec->patch_ops = alc_patch_ops;
17440
17441         if (board_config == ALC861VD_AUTO)
17442                 spec->init_hook = alc861vd_auto_init;
17443 #ifdef CONFIG_SND_HDA_POWER_SAVE
17444         if (!spec->loopback.amplist)
17445                 spec->loopback.amplist = alc861vd_loopbacks;
17446 #endif
17447
17448         return 0;
17449 }
17450
17451 /*
17452  * ALC662 support
17453  *
17454  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
17455  * configuration.  Each pin widget can choose any input DACs and a mixer.
17456  * Each ADC is connected from a mixer of all inputs.  This makes possible
17457  * 6-channel independent captures.
17458  *
17459  * In addition, an independent DAC for the multi-playback (not used in this
17460  * driver yet).
17461  */
17462 #define ALC662_DIGOUT_NID       0x06
17463 #define ALC662_DIGIN_NID        0x0a
17464
17465 static hda_nid_t alc662_dac_nids[4] = {
17466         /* front, rear, clfe, rear_surr */
17467         0x02, 0x03, 0x04
17468 };
17469
17470 static hda_nid_t alc272_dac_nids[2] = {
17471         0x02, 0x03
17472 };
17473
17474 static hda_nid_t alc662_adc_nids[2] = {
17475         /* ADC1-2 */
17476         0x09, 0x08
17477 };
17478
17479 static hda_nid_t alc272_adc_nids[1] = {
17480         /* ADC1-2 */
17481         0x08,
17482 };
17483
17484 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
17485 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
17486
17487
17488 /* input MUX */
17489 /* FIXME: should be a matrix-type input source selection */
17490 static struct hda_input_mux alc662_capture_source = {
17491         .num_items = 4,
17492         .items = {
17493                 { "Mic", 0x0 },
17494                 { "Front Mic", 0x1 },
17495                 { "Line", 0x2 },
17496                 { "CD", 0x4 },
17497         },
17498 };
17499
17500 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
17501         .num_items = 2,
17502         .items = {
17503                 { "Mic", 0x1 },
17504                 { "Line", 0x2 },
17505         },
17506 };
17507
17508 static struct hda_input_mux alc663_capture_source = {
17509         .num_items = 3,
17510         .items = {
17511                 { "Mic", 0x0 },
17512                 { "Front Mic", 0x1 },
17513                 { "Line", 0x2 },
17514         },
17515 };
17516
17517 #if 0 /* set to 1 for testing other input sources below */
17518 static struct hda_input_mux alc272_nc10_capture_source = {
17519         .num_items = 16,
17520         .items = {
17521                 { "Autoselect Mic", 0x0 },
17522                 { "Internal Mic", 0x1 },
17523                 { "In-0x02", 0x2 },
17524                 { "In-0x03", 0x3 },
17525                 { "In-0x04", 0x4 },
17526                 { "In-0x05", 0x5 },
17527                 { "In-0x06", 0x6 },
17528                 { "In-0x07", 0x7 },
17529                 { "In-0x08", 0x8 },
17530                 { "In-0x09", 0x9 },
17531                 { "In-0x0a", 0x0a },
17532                 { "In-0x0b", 0x0b },
17533                 { "In-0x0c", 0x0c },
17534                 { "In-0x0d", 0x0d },
17535                 { "In-0x0e", 0x0e },
17536                 { "In-0x0f", 0x0f },
17537         },
17538 };
17539 #endif
17540
17541 /*
17542  * 2ch mode
17543  */
17544 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
17545         { 2, NULL }
17546 };
17547
17548 /*
17549  * 2ch mode
17550  */
17551 static struct hda_verb alc662_3ST_ch2_init[] = {
17552         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
17553         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17554         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
17555         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17556         { } /* end */
17557 };
17558
17559 /*
17560  * 6ch mode
17561  */
17562 static struct hda_verb alc662_3ST_ch6_init[] = {
17563         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17564         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17565         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
17566         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17567         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17568         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
17569         { } /* end */
17570 };
17571
17572 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
17573         { 2, alc662_3ST_ch2_init },
17574         { 6, alc662_3ST_ch6_init },
17575 };
17576
17577 /*
17578  * 2ch mode
17579  */
17580 static struct hda_verb alc662_sixstack_ch6_init[] = {
17581         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17582         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17583         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17584         { } /* end */
17585 };
17586
17587 /*
17588  * 6ch mode
17589  */
17590 static struct hda_verb alc662_sixstack_ch8_init[] = {
17591         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17592         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17593         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17594         { } /* end */
17595 };
17596
17597 static struct hda_channel_mode alc662_5stack_modes[2] = {
17598         { 2, alc662_sixstack_ch6_init },
17599         { 6, alc662_sixstack_ch8_init },
17600 };
17601
17602 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
17603  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
17604  */
17605
17606 static struct snd_kcontrol_new alc662_base_mixer[] = {
17607         /* output mixer control */
17608         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
17609         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17610         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
17611         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17612         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17613         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17614         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17615         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17616         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17617
17618         /*Input mixer control */
17619         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
17620         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
17621         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
17622         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
17623         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
17624         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
17625         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
17626         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
17627         { } /* end */
17628 };
17629
17630 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
17631         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17632         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17633         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17634         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17635         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17636         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17637         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17638         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17639         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17640         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17641         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17642         { } /* end */
17643 };
17644
17645 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
17646         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17647         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17648         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17649         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17650         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17651         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17652         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17653         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17654         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17655         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17656         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17657         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17658         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17659         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17660         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17661         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17662         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17663         { } /* end */
17664 };
17665
17666 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
17667         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17668         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
17669         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17670         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
17671         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17672         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17673         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17674         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17675         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17676         { } /* end */
17677 };
17678
17679 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
17680         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17681         ALC262_HIPPO_MASTER_SWITCH,
17682
17683         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
17684         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17685         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17686
17687         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
17688         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17689         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17690         { } /* end */
17691 };
17692
17693 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
17694         ALC262_HIPPO_MASTER_SWITCH,
17695         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17696         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17697         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17698         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17699         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
17700         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17701         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, 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         { } /* end */
17705 };
17706
17707 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
17708         .ops = &snd_hda_bind_vol,
17709         .values = {
17710                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17711                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
17712                 0
17713         },
17714 };
17715
17716 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
17717         .ops = &snd_hda_bind_sw,
17718         .values = {
17719                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17720                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17721                 0
17722         },
17723 };
17724
17725 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
17726         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17727         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
17728         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17729         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17730         { } /* end */
17731 };
17732
17733 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
17734         .ops = &snd_hda_bind_sw,
17735         .values = {
17736                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17737                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17738                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17739                 0
17740         },
17741 };
17742
17743 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
17744         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17745         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_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         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17749         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17750
17751         { } /* end */
17752 };
17753
17754 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
17755         .ops = &snd_hda_bind_sw,
17756         .values = {
17757                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17758                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17759                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17760                 0
17761         },
17762 };
17763
17764 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
17765         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17766         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
17767         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17768         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17769         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17770         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17771         { } /* end */
17772 };
17773
17774 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
17775         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17776         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17777         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17778         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17779         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17780         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17781         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17782         { } /* end */
17783 };
17784
17785 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
17786         .ops = &snd_hda_bind_vol,
17787         .values = {
17788                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17789                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
17790                 0
17791         },
17792 };
17793
17794 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
17795         .ops = &snd_hda_bind_sw,
17796         .values = {
17797                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17798                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
17799                 0
17800         },
17801 };
17802
17803 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
17804         HDA_BIND_VOL("Master Playback Volume",
17805                                 &alc663_asus_two_bind_master_vol),
17806         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17807         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17808         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17809         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17810         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17811         { } /* end */
17812 };
17813
17814 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
17815         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17816         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17817         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17818         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17819         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17820         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17821         { } /* end */
17822 };
17823
17824 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
17825         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17826         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17827         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17828         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17829         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17830
17831         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17832         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17833         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17834         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17835         { } /* end */
17836 };
17837
17838 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
17839         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17840         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17841         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17842
17843         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17844         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17845         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17846         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17847         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17848         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17849         { } /* end */
17850 };
17851
17852 static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
17853         .ops = &snd_hda_bind_sw,
17854         .values = {
17855                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17856                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17857                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17858                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17859                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17860                 0
17861         },
17862 };
17863
17864 static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
17865         .ops = &snd_hda_bind_sw,
17866         .values = {
17867                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17868                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17869                 0
17870         },
17871 };
17872
17873 static struct snd_kcontrol_new alc663_mode7_mixer[] = {
17874         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17875         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17876         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17877         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17878         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17879         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17880         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17881         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17882         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17883         { } /* end */
17884 };
17885
17886 static struct snd_kcontrol_new alc663_mode8_mixer[] = {
17887         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17888         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17889         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17890         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17891         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17892         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17893         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17894         { } /* end */
17895 };
17896
17897
17898 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
17899         {
17900                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
17901                 .name = "Channel Mode",
17902                 .info = alc_ch_mode_info,
17903                 .get = alc_ch_mode_get,
17904                 .put = alc_ch_mode_put,
17905         },
17906         { } /* end */
17907 };
17908
17909 static struct hda_verb alc662_init_verbs[] = {
17910         /* ADC: mute amp left and right */
17911         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17912         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
17913
17914         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17915         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17916         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17917         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17918         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17919         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17920
17921         /* Front Pin: output 0 (0x0c) */
17922         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17923         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17924
17925         /* Rear Pin: output 1 (0x0d) */
17926         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17927         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17928
17929         /* CLFE Pin: output 2 (0x0e) */
17930         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17931         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17932
17933         /* Mic (rear) pin: input vref at 80% */
17934         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17935         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17936         /* Front Mic pin: input vref at 80% */
17937         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17938         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17939         /* Line In pin: input */
17940         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17941         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17942         /* Line-2 In: Headphone output (output 0 - 0x0c) */
17943         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17944         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17945         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
17946         /* CD pin widget for input */
17947         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17948
17949         /* FIXME: use matrix-type input source selection */
17950         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
17951         /* Input mixer */
17952         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17953         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17954
17955         /* always trun on EAPD */
17956         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
17957         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
17958
17959         { }
17960 };
17961
17962 static struct hda_verb alc663_init_verbs[] = {
17963         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17964         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17965         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17966         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17967         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17968         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17969         { }
17970 };
17971
17972 static struct hda_verb alc272_init_verbs[] = {
17973         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17974         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17975         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17976         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17977         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17978         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17979         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17980         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17981         { }
17982 };
17983
17984 static struct hda_verb alc662_sue_init_verbs[] = {
17985         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17986         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17987         {}
17988 };
17989
17990 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
17991         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17992         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17993         {}
17994 };
17995
17996 /* Set Unsolicited Event*/
17997 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
17998         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17999         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18000         {}
18001 };
18002
18003 static struct hda_verb alc663_m51va_init_verbs[] = {
18004         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18005         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18006         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18007         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18008         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18009         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18010         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18011         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18012         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18013         {}
18014 };
18015
18016 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
18017         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18018         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18019         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18020         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18021         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18022         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18023         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18024         {}
18025 };
18026
18027 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
18028         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18029         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18030         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18031         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
18032         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18033         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18034         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18035         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18036         {}
18037 };
18038
18039 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
18040         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18041         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18042         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18043         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18044         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18045         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18046         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18047         {}
18048 };
18049
18050 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
18051         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18052         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18053         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18054         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
18055         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18056         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18057         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
18058         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18059         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18060         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18061         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18062         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18063         {}
18064 };
18065
18066 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
18067         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18068         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18069         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18070         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18071         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18072         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18073         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18074         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18075         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18076         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18077         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18078         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18079         {}
18080 };
18081
18082 static struct hda_verb alc663_g71v_init_verbs[] = {
18083         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18084         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
18085         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
18086
18087         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18088         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18089         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
18090
18091         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
18092         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
18093         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
18094         {}
18095 };
18096
18097 static struct hda_verb alc663_g50v_init_verbs[] = {
18098         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18099         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18100         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
18101
18102         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18103         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18104         {}
18105 };
18106
18107 static struct hda_verb alc662_ecs_init_verbs[] = {
18108         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
18109         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18110         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18111         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18112         {}
18113 };
18114
18115 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
18116         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18117         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18118         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18119         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18120         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18121         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18122         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18123         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18124         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18125         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18126         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18127         {}
18128 };
18129
18130 static struct hda_verb alc272_dell_init_verbs[] = {
18131         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18132         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18133         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18134         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18135         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18136         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18137         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18138         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18139         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18140         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18141         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18142         {}
18143 };
18144
18145 static struct hda_verb alc663_mode7_init_verbs[] = {
18146         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18147         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18148         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18149         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18150         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18151         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18152         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
18153         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18154         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18155         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18156         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18157         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18158         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18159         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18160         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18161         {}
18162 };
18163
18164 static struct hda_verb alc663_mode8_init_verbs[] = {
18165         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18166         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18167         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18168         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
18169         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18170         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18171         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18172         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18173         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18174         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18175         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18176         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18177         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18178         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18179         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18180         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18181         {}
18182 };
18183
18184 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
18185         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
18186         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
18187         { } /* end */
18188 };
18189
18190 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
18191         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
18192         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
18193         { } /* end */
18194 };
18195
18196 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
18197 {
18198         unsigned int present;
18199         unsigned char bits;
18200
18201         present = snd_hda_jack_detect(codec, 0x14);
18202         bits = present ? HDA_AMP_MUTE : 0;
18203
18204         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18205                                  HDA_AMP_MUTE, bits);
18206 }
18207
18208 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
18209 {
18210         unsigned int present;
18211         unsigned char bits;
18212
18213         present = snd_hda_jack_detect(codec, 0x1b);
18214         bits = present ? HDA_AMP_MUTE : 0;
18215
18216         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18217                                  HDA_AMP_MUTE, bits);
18218         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18219                                  HDA_AMP_MUTE, bits);
18220 }
18221
18222 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
18223                                            unsigned int res)
18224 {
18225         if ((res >> 26) == ALC880_HP_EVENT)
18226                 alc662_lenovo_101e_all_automute(codec);
18227         if ((res >> 26) == ALC880_FRONT_EVENT)
18228                 alc662_lenovo_101e_ispeaker_automute(codec);
18229 }
18230
18231 /* unsolicited event for HP jack sensing */
18232 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
18233                                      unsigned int res)
18234 {
18235         if ((res >> 26) == ALC880_MIC_EVENT)
18236                 alc_mic_automute(codec);
18237         else
18238                 alc262_hippo_unsol_event(codec, res);
18239 }
18240
18241 static void alc662_eeepc_setup(struct hda_codec *codec)
18242 {
18243         struct alc_spec *spec = codec->spec;
18244
18245         alc262_hippo1_setup(codec);
18246         spec->ext_mic.pin = 0x18;
18247         spec->ext_mic.mux_idx = 0;
18248         spec->int_mic.pin = 0x19;
18249         spec->int_mic.mux_idx = 1;
18250         spec->auto_mic = 1;
18251 }
18252
18253 static void alc662_eeepc_inithook(struct hda_codec *codec)
18254 {
18255         alc262_hippo_automute(codec);
18256         alc_mic_automute(codec);
18257 }
18258
18259 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
18260 {
18261         struct alc_spec *spec = codec->spec;
18262
18263         spec->autocfg.hp_pins[0] = 0x14;
18264         spec->autocfg.speaker_pins[0] = 0x1b;
18265 }
18266
18267 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
18268
18269 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
18270 {
18271         unsigned int present;
18272         unsigned char bits;
18273
18274         present = snd_hda_jack_detect(codec, 0x21);
18275         bits = present ? HDA_AMP_MUTE : 0;
18276         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18277                                  HDA_AMP_MUTE, bits);
18278         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18279                                  HDA_AMP_MUTE, bits);
18280 }
18281
18282 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
18283 {
18284         unsigned int present;
18285         unsigned char bits;
18286
18287         present = snd_hda_jack_detect(codec, 0x21);
18288         bits = present ? HDA_AMP_MUTE : 0;
18289         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18290                                  HDA_AMP_MUTE, bits);
18291         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18292                                  HDA_AMP_MUTE, bits);
18293         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18294                                  HDA_AMP_MUTE, bits);
18295         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18296                                  HDA_AMP_MUTE, bits);
18297 }
18298
18299 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
18300 {
18301         unsigned int present;
18302         unsigned char bits;
18303
18304         present = snd_hda_jack_detect(codec, 0x15);
18305         bits = present ? HDA_AMP_MUTE : 0;
18306         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18307                                  HDA_AMP_MUTE, bits);
18308         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18309                                  HDA_AMP_MUTE, bits);
18310         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18311                                  HDA_AMP_MUTE, bits);
18312         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18313                                  HDA_AMP_MUTE, bits);
18314 }
18315
18316 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
18317 {
18318         unsigned int present;
18319         unsigned char bits;
18320
18321         present = snd_hda_jack_detect(codec, 0x1b);
18322         bits = present ? 0 : PIN_OUT;
18323         snd_hda_codec_write(codec, 0x14, 0,
18324                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
18325 }
18326
18327 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
18328 {
18329         unsigned int present1, present2;
18330
18331         present1 = snd_hda_jack_detect(codec, 0x21);
18332         present2 = snd_hda_jack_detect(codec, 0x15);
18333
18334         if (present1 || present2) {
18335                 snd_hda_codec_write_cache(codec, 0x14, 0,
18336                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18337         } else {
18338                 snd_hda_codec_write_cache(codec, 0x14, 0,
18339                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18340         }
18341 }
18342
18343 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
18344 {
18345         unsigned int present1, present2;
18346
18347         present1 = snd_hda_jack_detect(codec, 0x1b);
18348         present2 = snd_hda_jack_detect(codec, 0x15);
18349
18350         if (present1 || present2) {
18351                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18352                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
18353                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18354                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
18355         } else {
18356                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18357                                          HDA_AMP_MUTE, 0);
18358                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18359                                          HDA_AMP_MUTE, 0);
18360         }
18361 }
18362
18363 static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
18364 {
18365         unsigned int present1, present2;
18366
18367         present1 = snd_hda_codec_read(codec, 0x1b, 0,
18368                         AC_VERB_GET_PIN_SENSE, 0)
18369                         & AC_PINSENSE_PRESENCE;
18370         present2 = snd_hda_codec_read(codec, 0x21, 0,
18371                         AC_VERB_GET_PIN_SENSE, 0)
18372                         & AC_PINSENSE_PRESENCE;
18373
18374         if (present1 || present2) {
18375                 snd_hda_codec_write_cache(codec, 0x14, 0,
18376                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18377                 snd_hda_codec_write_cache(codec, 0x17, 0,
18378                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18379         } else {
18380                 snd_hda_codec_write_cache(codec, 0x14, 0,
18381                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18382                 snd_hda_codec_write_cache(codec, 0x17, 0,
18383                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18384         }
18385 }
18386
18387 static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
18388 {
18389         unsigned int present1, present2;
18390
18391         present1 = snd_hda_codec_read(codec, 0x21, 0,
18392                         AC_VERB_GET_PIN_SENSE, 0)
18393                         & AC_PINSENSE_PRESENCE;
18394         present2 = snd_hda_codec_read(codec, 0x15, 0,
18395                         AC_VERB_GET_PIN_SENSE, 0)
18396                         & AC_PINSENSE_PRESENCE;
18397
18398         if (present1 || present2) {
18399                 snd_hda_codec_write_cache(codec, 0x14, 0,
18400                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18401                 snd_hda_codec_write_cache(codec, 0x17, 0,
18402                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18403         } else {
18404                 snd_hda_codec_write_cache(codec, 0x14, 0,
18405                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18406                 snd_hda_codec_write_cache(codec, 0x17, 0,
18407                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18408         }
18409 }
18410
18411 static void alc663_m51va_unsol_event(struct hda_codec *codec,
18412                                            unsigned int res)
18413 {
18414         switch (res >> 26) {
18415         case ALC880_HP_EVENT:
18416                 alc663_m51va_speaker_automute(codec);
18417                 break;
18418         case ALC880_MIC_EVENT:
18419                 alc_mic_automute(codec);
18420                 break;
18421         }
18422 }
18423
18424 static void alc663_m51va_setup(struct hda_codec *codec)
18425 {
18426         struct alc_spec *spec = codec->spec;
18427         spec->ext_mic.pin = 0x18;
18428         spec->ext_mic.mux_idx = 0;
18429         spec->int_mic.pin = 0x12;
18430         spec->int_mic.mux_idx = 9;
18431         spec->auto_mic = 1;
18432 }
18433
18434 static void alc663_m51va_inithook(struct hda_codec *codec)
18435 {
18436         alc663_m51va_speaker_automute(codec);
18437         alc_mic_automute(codec);
18438 }
18439
18440 /* ***************** Mode1 ******************************/
18441 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
18442
18443 static void alc663_mode1_setup(struct hda_codec *codec)
18444 {
18445         struct alc_spec *spec = codec->spec;
18446         spec->ext_mic.pin = 0x18;
18447         spec->ext_mic.mux_idx = 0;
18448         spec->int_mic.pin = 0x19;
18449         spec->int_mic.mux_idx = 1;
18450         spec->auto_mic = 1;
18451 }
18452
18453 #define alc663_mode1_inithook           alc663_m51va_inithook
18454
18455 /* ***************** Mode2 ******************************/
18456 static void alc662_mode2_unsol_event(struct hda_codec *codec,
18457                                            unsigned int res)
18458 {
18459         switch (res >> 26) {
18460         case ALC880_HP_EVENT:
18461                 alc662_f5z_speaker_automute(codec);
18462                 break;
18463         case ALC880_MIC_EVENT:
18464                 alc_mic_automute(codec);
18465                 break;
18466         }
18467 }
18468
18469 #define alc662_mode2_setup      alc663_mode1_setup
18470
18471 static void alc662_mode2_inithook(struct hda_codec *codec)
18472 {
18473         alc662_f5z_speaker_automute(codec);
18474         alc_mic_automute(codec);
18475 }
18476 /* ***************** Mode3 ******************************/
18477 static void alc663_mode3_unsol_event(struct hda_codec *codec,
18478                                            unsigned int res)
18479 {
18480         switch (res >> 26) {
18481         case ALC880_HP_EVENT:
18482                 alc663_two_hp_m1_speaker_automute(codec);
18483                 break;
18484         case ALC880_MIC_EVENT:
18485                 alc_mic_automute(codec);
18486                 break;
18487         }
18488 }
18489
18490 #define alc663_mode3_setup      alc663_mode1_setup
18491
18492 static void alc663_mode3_inithook(struct hda_codec *codec)
18493 {
18494         alc663_two_hp_m1_speaker_automute(codec);
18495         alc_mic_automute(codec);
18496 }
18497 /* ***************** Mode4 ******************************/
18498 static void alc663_mode4_unsol_event(struct hda_codec *codec,
18499                                            unsigned int res)
18500 {
18501         switch (res >> 26) {
18502         case ALC880_HP_EVENT:
18503                 alc663_21jd_two_speaker_automute(codec);
18504                 break;
18505         case ALC880_MIC_EVENT:
18506                 alc_mic_automute(codec);
18507                 break;
18508         }
18509 }
18510
18511 #define alc663_mode4_setup      alc663_mode1_setup
18512
18513 static void alc663_mode4_inithook(struct hda_codec *codec)
18514 {
18515         alc663_21jd_two_speaker_automute(codec);
18516         alc_mic_automute(codec);
18517 }
18518 /* ***************** Mode5 ******************************/
18519 static void alc663_mode5_unsol_event(struct hda_codec *codec,
18520                                            unsigned int res)
18521 {
18522         switch (res >> 26) {
18523         case ALC880_HP_EVENT:
18524                 alc663_15jd_two_speaker_automute(codec);
18525                 break;
18526         case ALC880_MIC_EVENT:
18527                 alc_mic_automute(codec);
18528                 break;
18529         }
18530 }
18531
18532 #define alc663_mode5_setup      alc663_mode1_setup
18533
18534 static void alc663_mode5_inithook(struct hda_codec *codec)
18535 {
18536         alc663_15jd_two_speaker_automute(codec);
18537         alc_mic_automute(codec);
18538 }
18539 /* ***************** Mode6 ******************************/
18540 static void alc663_mode6_unsol_event(struct hda_codec *codec,
18541                                            unsigned int res)
18542 {
18543         switch (res >> 26) {
18544         case ALC880_HP_EVENT:
18545                 alc663_two_hp_m2_speaker_automute(codec);
18546                 break;
18547         case ALC880_MIC_EVENT:
18548                 alc_mic_automute(codec);
18549                 break;
18550         }
18551 }
18552
18553 #define alc663_mode6_setup      alc663_mode1_setup
18554
18555 static void alc663_mode6_inithook(struct hda_codec *codec)
18556 {
18557         alc663_two_hp_m2_speaker_automute(codec);
18558         alc_mic_automute(codec);
18559 }
18560
18561 /* ***************** Mode7 ******************************/
18562 static void alc663_mode7_unsol_event(struct hda_codec *codec,
18563                                            unsigned int res)
18564 {
18565         switch (res >> 26) {
18566         case ALC880_HP_EVENT:
18567                 alc663_two_hp_m7_speaker_automute(codec);
18568                 break;
18569         case ALC880_MIC_EVENT:
18570                 alc_mic_automute(codec);
18571                 break;
18572         }
18573 }
18574
18575 #define alc663_mode7_setup      alc663_mode1_setup
18576
18577 static void alc663_mode7_inithook(struct hda_codec *codec)
18578 {
18579         alc663_two_hp_m7_speaker_automute(codec);
18580         alc_mic_automute(codec);
18581 }
18582
18583 /* ***************** Mode8 ******************************/
18584 static void alc663_mode8_unsol_event(struct hda_codec *codec,
18585                                            unsigned int res)
18586 {
18587         switch (res >> 26) {
18588         case ALC880_HP_EVENT:
18589                 alc663_two_hp_m8_speaker_automute(codec);
18590                 break;
18591         case ALC880_MIC_EVENT:
18592                 alc_mic_automute(codec);
18593                 break;
18594         }
18595 }
18596
18597 #define alc663_mode8_setup      alc663_m51va_setup
18598
18599 static void alc663_mode8_inithook(struct hda_codec *codec)
18600 {
18601         alc663_two_hp_m8_speaker_automute(codec);
18602         alc_mic_automute(codec);
18603 }
18604
18605 static void alc663_g71v_hp_automute(struct hda_codec *codec)
18606 {
18607         unsigned int present;
18608         unsigned char bits;
18609
18610         present = snd_hda_jack_detect(codec, 0x21);
18611         bits = present ? HDA_AMP_MUTE : 0;
18612         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18613                                  HDA_AMP_MUTE, bits);
18614         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18615                                  HDA_AMP_MUTE, bits);
18616 }
18617
18618 static void alc663_g71v_front_automute(struct hda_codec *codec)
18619 {
18620         unsigned int present;
18621         unsigned char bits;
18622
18623         present = snd_hda_jack_detect(codec, 0x15);
18624         bits = present ? HDA_AMP_MUTE : 0;
18625         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18626                                  HDA_AMP_MUTE, bits);
18627 }
18628
18629 static void alc663_g71v_unsol_event(struct hda_codec *codec,
18630                                            unsigned int res)
18631 {
18632         switch (res >> 26) {
18633         case ALC880_HP_EVENT:
18634                 alc663_g71v_hp_automute(codec);
18635                 break;
18636         case ALC880_FRONT_EVENT:
18637                 alc663_g71v_front_automute(codec);
18638                 break;
18639         case ALC880_MIC_EVENT:
18640                 alc_mic_automute(codec);
18641                 break;
18642         }
18643 }
18644
18645 #define alc663_g71v_setup       alc663_m51va_setup
18646
18647 static void alc663_g71v_inithook(struct hda_codec *codec)
18648 {
18649         alc663_g71v_front_automute(codec);
18650         alc663_g71v_hp_automute(codec);
18651         alc_mic_automute(codec);
18652 }
18653
18654 static void alc663_g50v_unsol_event(struct hda_codec *codec,
18655                                            unsigned int res)
18656 {
18657         switch (res >> 26) {
18658         case ALC880_HP_EVENT:
18659                 alc663_m51va_speaker_automute(codec);
18660                 break;
18661         case ALC880_MIC_EVENT:
18662                 alc_mic_automute(codec);
18663                 break;
18664         }
18665 }
18666
18667 #define alc663_g50v_setup       alc663_m51va_setup
18668
18669 static void alc663_g50v_inithook(struct hda_codec *codec)
18670 {
18671         alc663_m51va_speaker_automute(codec);
18672         alc_mic_automute(codec);
18673 }
18674
18675 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
18676         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18677         ALC262_HIPPO_MASTER_SWITCH,
18678
18679         HDA_CODEC_VOLUME("Mic/LineIn Boost Volume", 0x18, 0, HDA_INPUT),
18680         HDA_CODEC_VOLUME("Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
18681         HDA_CODEC_MUTE("Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
18682
18683         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
18684         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18685         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18686         { } /* end */
18687 };
18688
18689 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
18690         /* Master Playback automatically created from Speaker and Headphone */
18691         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18692         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
18693         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
18694         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
18695
18696         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
18697         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
18698         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
18699
18700         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18701         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18702         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
18703         { } /* end */
18704 };
18705
18706 #ifdef CONFIG_SND_HDA_POWER_SAVE
18707 #define alc662_loopbacks        alc880_loopbacks
18708 #endif
18709
18710
18711 /* pcm configuration: identical with ALC880 */
18712 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
18713 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
18714 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
18715 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
18716
18717 /*
18718  * configuration and preset
18719  */
18720 static const char * const alc662_models[ALC662_MODEL_LAST] = {
18721         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
18722         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
18723         [ALC662_3ST_6ch]        = "3stack-6ch",
18724         [ALC662_5ST_DIG]        = "6stack-dig",
18725         [ALC662_LENOVO_101E]    = "lenovo-101e",
18726         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
18727         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
18728         [ALC662_ECS] = "ecs",
18729         [ALC663_ASUS_M51VA] = "m51va",
18730         [ALC663_ASUS_G71V] = "g71v",
18731         [ALC663_ASUS_H13] = "h13",
18732         [ALC663_ASUS_G50V] = "g50v",
18733         [ALC663_ASUS_MODE1] = "asus-mode1",
18734         [ALC662_ASUS_MODE2] = "asus-mode2",
18735         [ALC663_ASUS_MODE3] = "asus-mode3",
18736         [ALC663_ASUS_MODE4] = "asus-mode4",
18737         [ALC663_ASUS_MODE5] = "asus-mode5",
18738         [ALC663_ASUS_MODE6] = "asus-mode6",
18739         [ALC663_ASUS_MODE7] = "asus-mode7",
18740         [ALC663_ASUS_MODE8] = "asus-mode8",
18741         [ALC272_DELL]           = "dell",
18742         [ALC272_DELL_ZM1]       = "dell-zm1",
18743         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
18744         [ALC662_AUTO]           = "auto",
18745 };
18746
18747 static struct snd_pci_quirk alc662_cfg_tbl[] = {
18748         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
18749         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
18750         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
18751         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
18752         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
18753         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
18754         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
18755         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
18756         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
18757         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
18758         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
18759         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
18760         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
18761         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
18762         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
18763         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
18764         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
18765         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
18766         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
18767         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
18768         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
18769         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
18770         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
18771         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
18772         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
18773         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
18774         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
18775         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
18776         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
18777         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
18778         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
18779         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
18780         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
18781         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
18782         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
18783         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
18784         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
18785         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
18786         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
18787         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
18788         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
18789         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
18790         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
18791         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
18792         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
18793         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
18794         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
18795         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
18796         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
18797         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
18798         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
18799         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
18800         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
18801         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
18802         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
18803         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
18804         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
18805         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
18806         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
18807         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
18808         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
18809         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
18810         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
18811         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
18812                       ALC662_3ST_6ch_DIG),
18813         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
18814         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
18815         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
18816                       ALC662_3ST_6ch_DIG),
18817         SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
18818         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
18819         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
18820         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
18821         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
18822                                         ALC662_3ST_6ch_DIG),
18823         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
18824                            ALC663_ASUS_H13),
18825         SND_PCI_QUIRK(0x1991, 0x5628, "Ordissimo EVE", ALC662_LENOVO_101E),
18826         {}
18827 };
18828
18829 static struct alc_config_preset alc662_presets[] = {
18830         [ALC662_3ST_2ch_DIG] = {
18831                 .mixers = { alc662_3ST_2ch_mixer },
18832                 .init_verbs = { alc662_init_verbs },
18833                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18834                 .dac_nids = alc662_dac_nids,
18835                 .dig_out_nid = ALC662_DIGOUT_NID,
18836                 .dig_in_nid = ALC662_DIGIN_NID,
18837                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18838                 .channel_mode = alc662_3ST_2ch_modes,
18839                 .input_mux = &alc662_capture_source,
18840         },
18841         [ALC662_3ST_6ch_DIG] = {
18842                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18843                 .init_verbs = { alc662_init_verbs },
18844                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18845                 .dac_nids = alc662_dac_nids,
18846                 .dig_out_nid = ALC662_DIGOUT_NID,
18847                 .dig_in_nid = ALC662_DIGIN_NID,
18848                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18849                 .channel_mode = alc662_3ST_6ch_modes,
18850                 .need_dac_fix = 1,
18851                 .input_mux = &alc662_capture_source,
18852         },
18853         [ALC662_3ST_6ch] = {
18854                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18855                 .init_verbs = { alc662_init_verbs },
18856                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18857                 .dac_nids = alc662_dac_nids,
18858                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18859                 .channel_mode = alc662_3ST_6ch_modes,
18860                 .need_dac_fix = 1,
18861                 .input_mux = &alc662_capture_source,
18862         },
18863         [ALC662_5ST_DIG] = {
18864                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
18865                 .init_verbs = { alc662_init_verbs },
18866                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18867                 .dac_nids = alc662_dac_nids,
18868                 .dig_out_nid = ALC662_DIGOUT_NID,
18869                 .dig_in_nid = ALC662_DIGIN_NID,
18870                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
18871                 .channel_mode = alc662_5stack_modes,
18872                 .input_mux = &alc662_capture_source,
18873         },
18874         [ALC662_LENOVO_101E] = {
18875                 .mixers = { alc662_lenovo_101e_mixer },
18876                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
18877                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18878                 .dac_nids = alc662_dac_nids,
18879                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18880                 .channel_mode = alc662_3ST_2ch_modes,
18881                 .input_mux = &alc662_lenovo_101e_capture_source,
18882                 .unsol_event = alc662_lenovo_101e_unsol_event,
18883                 .init_hook = alc662_lenovo_101e_all_automute,
18884         },
18885         [ALC662_ASUS_EEEPC_P701] = {
18886                 .mixers = { alc662_eeepc_p701_mixer },
18887                 .init_verbs = { alc662_init_verbs,
18888                                 alc662_eeepc_sue_init_verbs },
18889                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18890                 .dac_nids = alc662_dac_nids,
18891                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18892                 .channel_mode = alc662_3ST_2ch_modes,
18893                 .unsol_event = alc662_eeepc_unsol_event,
18894                 .setup = alc662_eeepc_setup,
18895                 .init_hook = alc662_eeepc_inithook,
18896         },
18897         [ALC662_ASUS_EEEPC_EP20] = {
18898                 .mixers = { alc662_eeepc_ep20_mixer,
18899                             alc662_chmode_mixer },
18900                 .init_verbs = { alc662_init_verbs,
18901                                 alc662_eeepc_ep20_sue_init_verbs },
18902                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18903                 .dac_nids = alc662_dac_nids,
18904                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18905                 .channel_mode = alc662_3ST_6ch_modes,
18906                 .input_mux = &alc662_lenovo_101e_capture_source,
18907                 .unsol_event = alc662_eeepc_unsol_event,
18908                 .setup = alc662_eeepc_ep20_setup,
18909                 .init_hook = alc662_eeepc_ep20_inithook,
18910         },
18911         [ALC662_ECS] = {
18912                 .mixers = { alc662_ecs_mixer },
18913                 .init_verbs = { alc662_init_verbs,
18914                                 alc662_ecs_init_verbs },
18915                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18916                 .dac_nids = alc662_dac_nids,
18917                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18918                 .channel_mode = alc662_3ST_2ch_modes,
18919                 .unsol_event = alc662_eeepc_unsol_event,
18920                 .setup = alc662_eeepc_setup,
18921                 .init_hook = alc662_eeepc_inithook,
18922         },
18923         [ALC663_ASUS_M51VA] = {
18924                 .mixers = { alc663_m51va_mixer },
18925                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18926                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18927                 .dac_nids = alc662_dac_nids,
18928                 .dig_out_nid = ALC662_DIGOUT_NID,
18929                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18930                 .channel_mode = alc662_3ST_2ch_modes,
18931                 .unsol_event = alc663_m51va_unsol_event,
18932                 .setup = alc663_m51va_setup,
18933                 .init_hook = alc663_m51va_inithook,
18934         },
18935         [ALC663_ASUS_G71V] = {
18936                 .mixers = { alc663_g71v_mixer },
18937                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
18938                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18939                 .dac_nids = alc662_dac_nids,
18940                 .dig_out_nid = ALC662_DIGOUT_NID,
18941                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18942                 .channel_mode = alc662_3ST_2ch_modes,
18943                 .unsol_event = alc663_g71v_unsol_event,
18944                 .setup = alc663_g71v_setup,
18945                 .init_hook = alc663_g71v_inithook,
18946         },
18947         [ALC663_ASUS_H13] = {
18948                 .mixers = { alc663_m51va_mixer },
18949                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18950                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18951                 .dac_nids = alc662_dac_nids,
18952                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18953                 .channel_mode = alc662_3ST_2ch_modes,
18954                 .unsol_event = alc663_m51va_unsol_event,
18955                 .init_hook = alc663_m51va_inithook,
18956         },
18957         [ALC663_ASUS_G50V] = {
18958                 .mixers = { alc663_g50v_mixer },
18959                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
18960                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18961                 .dac_nids = alc662_dac_nids,
18962                 .dig_out_nid = ALC662_DIGOUT_NID,
18963                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18964                 .channel_mode = alc662_3ST_6ch_modes,
18965                 .input_mux = &alc663_capture_source,
18966                 .unsol_event = alc663_g50v_unsol_event,
18967                 .setup = alc663_g50v_setup,
18968                 .init_hook = alc663_g50v_inithook,
18969         },
18970         [ALC663_ASUS_MODE1] = {
18971                 .mixers = { alc663_m51va_mixer },
18972                 .cap_mixer = alc662_auto_capture_mixer,
18973                 .init_verbs = { alc662_init_verbs,
18974                                 alc663_21jd_amic_init_verbs },
18975                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18976                 .hp_nid = 0x03,
18977                 .dac_nids = alc662_dac_nids,
18978                 .dig_out_nid = ALC662_DIGOUT_NID,
18979                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18980                 .channel_mode = alc662_3ST_2ch_modes,
18981                 .unsol_event = alc663_mode1_unsol_event,
18982                 .setup = alc663_mode1_setup,
18983                 .init_hook = alc663_mode1_inithook,
18984         },
18985         [ALC662_ASUS_MODE2] = {
18986                 .mixers = { alc662_1bjd_mixer },
18987                 .cap_mixer = alc662_auto_capture_mixer,
18988                 .init_verbs = { alc662_init_verbs,
18989                                 alc662_1bjd_amic_init_verbs },
18990                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18991                 .dac_nids = alc662_dac_nids,
18992                 .dig_out_nid = ALC662_DIGOUT_NID,
18993                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18994                 .channel_mode = alc662_3ST_2ch_modes,
18995                 .unsol_event = alc662_mode2_unsol_event,
18996                 .setup = alc662_mode2_setup,
18997                 .init_hook = alc662_mode2_inithook,
18998         },
18999         [ALC663_ASUS_MODE3] = {
19000                 .mixers = { alc663_two_hp_m1_mixer },
19001                 .cap_mixer = alc662_auto_capture_mixer,
19002                 .init_verbs = { alc662_init_verbs,
19003                                 alc663_two_hp_amic_m1_init_verbs },
19004                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
19005                 .hp_nid = 0x03,
19006                 .dac_nids = alc662_dac_nids,
19007                 .dig_out_nid = ALC662_DIGOUT_NID,
19008                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19009                 .channel_mode = alc662_3ST_2ch_modes,
19010                 .unsol_event = alc663_mode3_unsol_event,
19011                 .setup = alc663_mode3_setup,
19012                 .init_hook = alc663_mode3_inithook,
19013         },
19014         [ALC663_ASUS_MODE4] = {
19015                 .mixers = { alc663_asus_21jd_clfe_mixer },
19016                 .cap_mixer = alc662_auto_capture_mixer,
19017                 .init_verbs = { alc662_init_verbs,
19018                                 alc663_21jd_amic_init_verbs},
19019                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
19020                 .hp_nid = 0x03,
19021                 .dac_nids = alc662_dac_nids,
19022                 .dig_out_nid = ALC662_DIGOUT_NID,
19023                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19024                 .channel_mode = alc662_3ST_2ch_modes,
19025                 .unsol_event = alc663_mode4_unsol_event,
19026                 .setup = alc663_mode4_setup,
19027                 .init_hook = alc663_mode4_inithook,
19028         },
19029         [ALC663_ASUS_MODE5] = {
19030                 .mixers = { alc663_asus_15jd_clfe_mixer },
19031                 .cap_mixer = alc662_auto_capture_mixer,
19032                 .init_verbs = { alc662_init_verbs,
19033                                 alc663_15jd_amic_init_verbs },
19034                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
19035                 .hp_nid = 0x03,
19036                 .dac_nids = alc662_dac_nids,
19037                 .dig_out_nid = ALC662_DIGOUT_NID,
19038                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19039                 .channel_mode = alc662_3ST_2ch_modes,
19040                 .unsol_event = alc663_mode5_unsol_event,
19041                 .setup = alc663_mode5_setup,
19042                 .init_hook = alc663_mode5_inithook,
19043         },
19044         [ALC663_ASUS_MODE6] = {
19045                 .mixers = { alc663_two_hp_m2_mixer },
19046                 .cap_mixer = alc662_auto_capture_mixer,
19047                 .init_verbs = { alc662_init_verbs,
19048                                 alc663_two_hp_amic_m2_init_verbs },
19049                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
19050                 .hp_nid = 0x03,
19051                 .dac_nids = alc662_dac_nids,
19052                 .dig_out_nid = ALC662_DIGOUT_NID,
19053                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19054                 .channel_mode = alc662_3ST_2ch_modes,
19055                 .unsol_event = alc663_mode6_unsol_event,
19056                 .setup = alc663_mode6_setup,
19057                 .init_hook = alc663_mode6_inithook,
19058         },
19059         [ALC663_ASUS_MODE7] = {
19060                 .mixers = { alc663_mode7_mixer },
19061                 .cap_mixer = alc662_auto_capture_mixer,
19062                 .init_verbs = { alc662_init_verbs,
19063                                 alc663_mode7_init_verbs },
19064                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
19065                 .hp_nid = 0x03,
19066                 .dac_nids = alc662_dac_nids,
19067                 .dig_out_nid = ALC662_DIGOUT_NID,
19068                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19069                 .channel_mode = alc662_3ST_2ch_modes,
19070                 .unsol_event = alc663_mode7_unsol_event,
19071                 .setup = alc663_mode7_setup,
19072                 .init_hook = alc663_mode7_inithook,
19073         },
19074         [ALC663_ASUS_MODE8] = {
19075                 .mixers = { alc663_mode8_mixer },
19076                 .cap_mixer = alc662_auto_capture_mixer,
19077                 .init_verbs = { alc662_init_verbs,
19078                                 alc663_mode8_init_verbs },
19079                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
19080                 .hp_nid = 0x03,
19081                 .dac_nids = alc662_dac_nids,
19082                 .dig_out_nid = ALC662_DIGOUT_NID,
19083                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19084                 .channel_mode = alc662_3ST_2ch_modes,
19085                 .unsol_event = alc663_mode8_unsol_event,
19086                 .setup = alc663_mode8_setup,
19087                 .init_hook = alc663_mode8_inithook,
19088         },
19089         [ALC272_DELL] = {
19090                 .mixers = { alc663_m51va_mixer },
19091                 .cap_mixer = alc272_auto_capture_mixer,
19092                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
19093                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
19094                 .dac_nids = alc662_dac_nids,
19095                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19096                 .adc_nids = alc272_adc_nids,
19097                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
19098                 .capsrc_nids = alc272_capsrc_nids,
19099                 .channel_mode = alc662_3ST_2ch_modes,
19100                 .unsol_event = alc663_m51va_unsol_event,
19101                 .setup = alc663_m51va_setup,
19102                 .init_hook = alc663_m51va_inithook,
19103         },
19104         [ALC272_DELL_ZM1] = {
19105                 .mixers = { alc663_m51va_mixer },
19106                 .cap_mixer = alc662_auto_capture_mixer,
19107                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
19108                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
19109                 .dac_nids = alc662_dac_nids,
19110                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19111                 .adc_nids = alc662_adc_nids,
19112                 .num_adc_nids = 1,
19113                 .capsrc_nids = alc662_capsrc_nids,
19114                 .channel_mode = alc662_3ST_2ch_modes,
19115                 .unsol_event = alc663_m51va_unsol_event,
19116                 .setup = alc663_m51va_setup,
19117                 .init_hook = alc663_m51va_inithook,
19118         },
19119         [ALC272_SAMSUNG_NC10] = {
19120                 .mixers = { alc272_nc10_mixer },
19121                 .init_verbs = { alc662_init_verbs,
19122                                 alc663_21jd_amic_init_verbs },
19123                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
19124                 .dac_nids = alc272_dac_nids,
19125                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19126                 .channel_mode = alc662_3ST_2ch_modes,
19127                 /*.input_mux = &alc272_nc10_capture_source,*/
19128                 .unsol_event = alc663_mode4_unsol_event,
19129                 .setup = alc663_mode4_setup,
19130                 .init_hook = alc663_mode4_inithook,
19131         },
19132 };
19133
19134
19135 /*
19136  * BIOS auto configuration
19137  */
19138
19139 /* convert from MIX nid to DAC */
19140 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
19141 {
19142         if (nid == 0x0f)
19143                 return 0x02;
19144         else if (nid >= 0x0c && nid <= 0x0e)
19145                 return nid - 0x0c + 0x02;
19146         else if (nid == 0x26) /* ALC887-VD has this DAC too */
19147                 return 0x25;
19148         else
19149                 return 0;
19150 }
19151
19152 /* get MIX nid connected to the given pin targeted to DAC */
19153 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
19154                                    hda_nid_t dac)
19155 {
19156         hda_nid_t mix[5];
19157         int i, num;
19158
19159         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
19160         for (i = 0; i < num; i++) {
19161                 if (alc662_mix_to_dac(mix[i]) == dac)
19162                         return mix[i];
19163         }
19164         return 0;
19165 }
19166
19167 /* look for an empty DAC slot */
19168 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
19169 {
19170         struct alc_spec *spec = codec->spec;
19171         hda_nid_t srcs[5];
19172         int i, j, num;
19173
19174         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
19175         if (num < 0)
19176                 return 0;
19177         for (i = 0; i < num; i++) {
19178                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
19179                 if (!nid)
19180                         continue;
19181                 for (j = 0; j < spec->multiout.num_dacs; j++)
19182                         if (spec->multiout.dac_nids[j] == nid)
19183                                 break;
19184                 if (j >= spec->multiout.num_dacs)
19185                         return nid;
19186         }
19187         return 0;
19188 }
19189
19190 /* fill in the dac_nids table from the parsed pin configuration */
19191 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
19192                                      const struct auto_pin_cfg *cfg)
19193 {
19194         struct alc_spec *spec = codec->spec;
19195         int i;
19196         hda_nid_t dac;
19197
19198         spec->multiout.dac_nids = spec->private_dac_nids;
19199         for (i = 0; i < cfg->line_outs; i++) {
19200                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
19201                 if (!dac)
19202                         continue;
19203                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19204         }
19205         return 0;
19206 }
19207
19208 static inline int __alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
19209                                        hda_nid_t nid, int idx, unsigned int chs)
19210 {
19211         return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx,
19212                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
19213 }
19214
19215 static inline int __alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
19216                                       hda_nid_t nid, int idx, unsigned int chs)
19217 {
19218         return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
19219                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
19220 }
19221
19222 #define alc662_add_vol_ctl(spec, pfx, nid, chs) \
19223         __alc662_add_vol_ctl(spec, pfx, nid, 0, chs)
19224 #define alc662_add_sw_ctl(spec, pfx, nid, chs) \
19225         __alc662_add_sw_ctl(spec, pfx, nid, 0, chs)
19226 #define alc662_add_stereo_vol(spec, pfx, nid) \
19227         alc662_add_vol_ctl(spec, pfx, nid, 3)
19228 #define alc662_add_stereo_sw(spec, pfx, nid) \
19229         alc662_add_sw_ctl(spec, pfx, nid, 3)
19230
19231 /* add playback controls from the parsed DAC table */
19232 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
19233                                              const struct auto_pin_cfg *cfg)
19234 {
19235         struct alc_spec *spec = codec->spec;
19236         static const char * const chname[4] = {
19237                 "Front", "Surround", NULL /*CLFE*/, "Side"
19238         };
19239         const char *pfx = alc_get_line_out_pfx(cfg, true);
19240         hda_nid_t nid, mix;
19241         int i, err;
19242
19243         for (i = 0; i < cfg->line_outs; i++) {
19244                 nid = spec->multiout.dac_nids[i];
19245                 if (!nid)
19246                         continue;
19247                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
19248                 if (!mix)
19249                         continue;
19250                 if (!pfx && i == 2) {
19251                         /* Center/LFE */
19252                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
19253                         if (err < 0)
19254                                 return err;
19255                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
19256                         if (err < 0)
19257                                 return err;
19258                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
19259                         if (err < 0)
19260                                 return err;
19261                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
19262                         if (err < 0)
19263                                 return err;
19264                 } else {
19265                         const char *name = pfx;
19266                         if (!name)
19267                                 name = chname[i];
19268                         err = __alc662_add_vol_ctl(spec, name, nid, i, 3);
19269                         if (err < 0)
19270                                 return err;
19271                         err = __alc662_add_sw_ctl(spec, name, mix, i, 3);
19272                         if (err < 0)
19273                                 return err;
19274                 }
19275         }
19276         return 0;
19277 }
19278
19279 /* add playback controls for speaker and HP outputs */
19280 /* return DAC nid if any new DAC is assigned */
19281 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
19282                                         const char *pfx)
19283 {
19284         struct alc_spec *spec = codec->spec;
19285         hda_nid_t nid, mix;
19286         int err;
19287
19288         if (!pin)
19289                 return 0;
19290         nid = alc662_look_for_dac(codec, pin);
19291         if (!nid) {
19292                 /* the corresponding DAC is already occupied */
19293                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
19294                         return 0; /* no way */
19295                 /* create a switch only */
19296                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19297                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
19298         }
19299
19300         mix = alc662_dac_to_mix(codec, pin, nid);
19301         if (!mix)
19302                 return 0;
19303         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19304         if (err < 0)
19305                 return err;
19306         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19307         if (err < 0)
19308                 return err;
19309         return nid;
19310 }
19311
19312 /* create playback/capture controls for input pins */
19313 #define alc662_auto_create_input_ctls \
19314         alc882_auto_create_input_ctls
19315
19316 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
19317                                               hda_nid_t nid, int pin_type,
19318                                               hda_nid_t dac)
19319 {
19320         int i, num;
19321         hda_nid_t srcs[HDA_MAX_CONNECTIONS];
19322
19323         alc_set_pin_output(codec, nid, pin_type);
19324         /* need the manual connection? */
19325         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
19326         if (num <= 1)
19327                 return;
19328         for (i = 0; i < num; i++) {
19329                 if (alc662_mix_to_dac(srcs[i]) != dac)
19330                         continue;
19331                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
19332                 return;
19333         }
19334 }
19335
19336 static void alc662_auto_init_multi_out(struct hda_codec *codec)
19337 {
19338         struct alc_spec *spec = codec->spec;
19339         int pin_type = get_pin_type(spec->autocfg.line_out_type);
19340         int i;
19341
19342         for (i = 0; i <= HDA_SIDE; i++) {
19343                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
19344                 if (nid)
19345                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
19346                                         spec->multiout.dac_nids[i]);
19347         }
19348 }
19349
19350 static void alc662_auto_init_hp_out(struct hda_codec *codec)
19351 {
19352         struct alc_spec *spec = codec->spec;
19353         hda_nid_t pin;
19354
19355         pin = spec->autocfg.hp_pins[0];
19356         if (pin)
19357                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
19358                                                   spec->multiout.hp_nid);
19359         pin = spec->autocfg.speaker_pins[0];
19360         if (pin)
19361                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
19362                                         spec->multiout.extra_out_nid[0]);
19363 }
19364
19365 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
19366
19367 static void alc662_auto_init_analog_input(struct hda_codec *codec)
19368 {
19369         struct alc_spec *spec = codec->spec;
19370         struct auto_pin_cfg *cfg = &spec->autocfg;
19371         int i;
19372
19373         for (i = 0; i < cfg->num_inputs; i++) {
19374                 hda_nid_t nid = cfg->inputs[i].pin;
19375                 if (alc_is_input_pin(codec, nid)) {
19376                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
19377                         if (nid != ALC662_PIN_CD_NID &&
19378                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
19379                                 snd_hda_codec_write(codec, nid, 0,
19380                                                     AC_VERB_SET_AMP_GAIN_MUTE,
19381                                                     AMP_OUT_MUTE);
19382                 }
19383         }
19384 }
19385
19386 #define alc662_auto_init_input_src      alc882_auto_init_input_src
19387
19388 static int alc662_parse_auto_config(struct hda_codec *codec)
19389 {
19390         struct alc_spec *spec = codec->spec;
19391         int err;
19392         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
19393
19394         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19395                                            alc662_ignore);
19396         if (err < 0)
19397                 return err;
19398         if (!spec->autocfg.line_outs)
19399                 return 0; /* can't find valid BIOS pin config */
19400
19401         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
19402         if (err < 0)
19403                 return err;
19404         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
19405         if (err < 0)
19406                 return err;
19407         err = alc662_auto_create_extra_out(codec,
19408                                            spec->autocfg.speaker_pins[0],
19409                                            "Speaker");
19410         if (err < 0)
19411                 return err;
19412         if (err)
19413                 spec->multiout.extra_out_nid[0] = err;
19414         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
19415                                            "Headphone");
19416         if (err < 0)
19417                 return err;
19418         if (err)
19419                 spec->multiout.hp_nid = err;
19420         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
19421         if (err < 0)
19422                 return err;
19423
19424         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
19425
19426         alc_auto_parse_digital(codec);
19427
19428         if (spec->kctls.list)
19429                 add_mixer(spec, spec->kctls.list);
19430
19431         spec->num_mux_defs = 1;
19432         spec->input_mux = &spec->private_imux[0];
19433
19434         add_verb(spec, alc662_init_verbs);
19435         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19436             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19437                 add_verb(spec, alc663_init_verbs);
19438
19439         if (codec->vendor_id == 0x10ec0272)
19440                 add_verb(spec, alc272_init_verbs);
19441
19442         err = alc_auto_add_mic_boost(codec);
19443         if (err < 0)
19444                 return err;
19445
19446         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19447             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19448             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
19449         else
19450             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
19451
19452         return 1;
19453 }
19454
19455 /* additional initialization for auto-configuration model */
19456 static void alc662_auto_init(struct hda_codec *codec)
19457 {
19458         struct alc_spec *spec = codec->spec;
19459         alc662_auto_init_multi_out(codec);
19460         alc662_auto_init_hp_out(codec);
19461         alc662_auto_init_analog_input(codec);
19462         alc662_auto_init_input_src(codec);
19463         alc_auto_init_digital(codec);
19464         if (spec->unsol_event)
19465                 alc_inithook(codec);
19466 }
19467
19468 static void alc272_fixup_mario(struct hda_codec *codec,
19469                                const struct alc_fixup *fix, int action)
19470 {
19471         if (action != ALC_FIXUP_ACT_PROBE)
19472                 return;
19473         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
19474                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
19475                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
19476                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
19477                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
19478                 printk(KERN_WARNING
19479                        "hda_codec: failed to override amp caps for NID 0x2\n");
19480 }
19481
19482 enum {
19483         ALC662_FIXUP_ASPIRE,
19484         ALC662_FIXUP_IDEAPAD,
19485         ALC272_FIXUP_MARIO,
19486         ALC662_FIXUP_CZC_P10T,
19487 };
19488
19489 static const struct alc_fixup alc662_fixups[] = {
19490         [ALC662_FIXUP_ASPIRE] = {
19491                 .type = ALC_FIXUP_PINS,
19492                 .v.pins = (const struct alc_pincfg[]) {
19493                         { 0x15, 0x99130112 }, /* subwoofer */
19494                         { }
19495                 }
19496         },
19497         [ALC662_FIXUP_IDEAPAD] = {
19498                 .type = ALC_FIXUP_PINS,
19499                 .v.pins = (const struct alc_pincfg[]) {
19500                         { 0x17, 0x99130112 }, /* subwoofer */
19501                         { }
19502                 }
19503         },
19504         [ALC272_FIXUP_MARIO] = {
19505                 .type = ALC_FIXUP_FUNC,
19506                 .v.func = alc272_fixup_mario,
19507         },
19508         [ALC662_FIXUP_CZC_P10T] = {
19509                 .type = ALC_FIXUP_VERBS,
19510                 .v.verbs = (const struct hda_verb[]) {
19511                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
19512                         {}
19513                 }
19514         },
19515 };
19516
19517 static struct snd_pci_quirk alc662_fixup_tbl[] = {
19518         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
19519         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
19520         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
19521         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
19522         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
19523         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
19524         {}
19525 };
19526
19527 static const struct alc_model_fixup alc662_fixup_models[] = {
19528         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
19529         {}
19530 };
19531
19532
19533 static int patch_alc662(struct hda_codec *codec)
19534 {
19535         struct alc_spec *spec;
19536         int err, board_config;
19537         int coef;
19538
19539         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19540         if (!spec)
19541                 return -ENOMEM;
19542
19543         codec->spec = spec;
19544
19545         alc_auto_parse_customize_define(codec);
19546
19547         alc_fix_pll_init(codec, 0x20, 0x04, 15);
19548
19549         coef = alc_read_coef_idx(codec, 0);
19550         if (coef == 0x8020 || coef == 0x8011)
19551                 alc_codec_rename(codec, "ALC661");
19552         else if (coef & (1 << 14) &&
19553                 codec->bus->pci->subsystem_vendor == 0x1025 &&
19554                 spec->cdefine.platform_type == 1)
19555                 alc_codec_rename(codec, "ALC272X");
19556         else if (coef == 0x4011)
19557                 alc_codec_rename(codec, "ALC656");
19558
19559         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
19560                                                   alc662_models,
19561                                                   alc662_cfg_tbl);
19562         if (board_config < 0) {
19563                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19564                        codec->chip_name);
19565                 board_config = ALC662_AUTO;
19566         }
19567
19568         if (board_config == ALC662_AUTO) {
19569                 alc_pick_fixup(codec, alc662_fixup_models,
19570                                alc662_fixup_tbl, alc662_fixups);
19571                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
19572                 /* automatic parse from the BIOS config */
19573                 err = alc662_parse_auto_config(codec);
19574                 if (err < 0) {
19575                         alc_free(codec);
19576                         return err;
19577                 } else if (!err) {
19578                         printk(KERN_INFO
19579                                "hda_codec: Cannot set up configuration "
19580                                "from BIOS.  Using base mode...\n");
19581                         board_config = ALC662_3ST_2ch_DIG;
19582                 }
19583         }
19584
19585         if (has_cdefine_beep(codec)) {
19586                 err = snd_hda_attach_beep_device(codec, 0x1);
19587                 if (err < 0) {
19588                         alc_free(codec);
19589                         return err;
19590                 }
19591         }
19592
19593         if (board_config != ALC662_AUTO)
19594                 setup_preset(codec, &alc662_presets[board_config]);
19595
19596         spec->stream_analog_playback = &alc662_pcm_analog_playback;
19597         spec->stream_analog_capture = &alc662_pcm_analog_capture;
19598
19599         spec->stream_digital_playback = &alc662_pcm_digital_playback;
19600         spec->stream_digital_capture = &alc662_pcm_digital_capture;
19601
19602         if (!spec->adc_nids) {
19603                 spec->adc_nids = alc662_adc_nids;
19604                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
19605         }
19606         if (!spec->capsrc_nids)
19607                 spec->capsrc_nids = alc662_capsrc_nids;
19608
19609         if (!spec->cap_mixer)
19610                 set_capture_mixer(codec);
19611
19612         if (has_cdefine_beep(codec)) {
19613                 switch (codec->vendor_id) {
19614                 case 0x10ec0662:
19615                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
19616                         break;
19617                 case 0x10ec0272:
19618                 case 0x10ec0663:
19619                 case 0x10ec0665:
19620                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
19621                         break;
19622                 case 0x10ec0273:
19623                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
19624                         break;
19625                 }
19626         }
19627         spec->vmaster_nid = 0x02;
19628
19629         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
19630
19631         codec->patch_ops = alc_patch_ops;
19632         if (board_config == ALC662_AUTO)
19633                 spec->init_hook = alc662_auto_init;
19634
19635         alc_init_jacks(codec);
19636
19637 #ifdef CONFIG_SND_HDA_POWER_SAVE
19638         if (!spec->loopback.amplist)
19639                 spec->loopback.amplist = alc662_loopbacks;
19640 #endif
19641
19642         return 0;
19643 }
19644
19645 static int patch_alc888(struct hda_codec *codec)
19646 {
19647         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
19648                 kfree(codec->chip_name);
19649                 if (codec->vendor_id == 0x10ec0887)
19650                         codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL);
19651                 else
19652                         codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
19653                 if (!codec->chip_name) {
19654                         alc_free(codec);
19655                         return -ENOMEM;
19656                 }
19657                 return patch_alc662(codec);
19658         }
19659         return patch_alc882(codec);
19660 }
19661
19662 /*
19663  * ALC680 support
19664  */
19665 #define ALC680_DIGIN_NID        ALC880_DIGIN_NID
19666 #define ALC680_DIGOUT_NID       ALC880_DIGOUT_NID
19667 #define alc680_modes            alc260_modes
19668
19669 static hda_nid_t alc680_dac_nids[3] = {
19670         /* Lout1, Lout2, hp */
19671         0x02, 0x03, 0x04
19672 };
19673
19674 static hda_nid_t alc680_adc_nids[3] = {
19675         /* ADC0-2 */
19676         /* DMIC, MIC, Line-in*/
19677         0x07, 0x08, 0x09
19678 };
19679
19680 /*
19681  * Analog capture ADC cgange
19682  */
19683 static void alc680_rec_autoswitch(struct hda_codec *codec)
19684 {
19685         struct alc_spec *spec = codec->spec;
19686         struct auto_pin_cfg *cfg = &spec->autocfg;
19687         int pin_found = 0;
19688         int type_found = AUTO_PIN_LAST;
19689         hda_nid_t nid;
19690         int i;
19691
19692         for (i = 0; i < cfg->num_inputs; i++) {
19693                 nid = cfg->inputs[i].pin;
19694                 if (!(snd_hda_query_pin_caps(codec, nid) &
19695                       AC_PINCAP_PRES_DETECT))
19696                         continue;
19697                 if (snd_hda_jack_detect(codec, nid)) {
19698                         if (cfg->inputs[i].type < type_found) {
19699                                 type_found = cfg->inputs[i].type;
19700                                 pin_found = nid;
19701                         }
19702                 }
19703         }
19704
19705         nid = 0x07;
19706         if (pin_found)
19707                 snd_hda_get_connections(codec, pin_found, &nid, 1);
19708
19709         if (nid != spec->cur_adc)
19710                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
19711         spec->cur_adc = nid;
19712         snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0,
19713                                    spec->cur_adc_format);
19714 }
19715
19716 static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
19717                                       struct hda_codec *codec,
19718                                       unsigned int stream_tag,
19719                                       unsigned int format,
19720                                       struct snd_pcm_substream *substream)
19721 {
19722         struct alc_spec *spec = codec->spec;
19723
19724         spec->cur_adc = 0x07;
19725         spec->cur_adc_stream_tag = stream_tag;
19726         spec->cur_adc_format = format;
19727
19728         alc680_rec_autoswitch(codec);
19729         return 0;
19730 }
19731
19732 static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
19733                                       struct hda_codec *codec,
19734                                       struct snd_pcm_substream *substream)
19735 {
19736         snd_hda_codec_cleanup_stream(codec, 0x07);
19737         snd_hda_codec_cleanup_stream(codec, 0x08);
19738         snd_hda_codec_cleanup_stream(codec, 0x09);
19739         return 0;
19740 }
19741
19742 static struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
19743         .substreams = 1, /* can be overridden */
19744         .channels_min = 2,
19745         .channels_max = 2,
19746         /* NID is set in alc_build_pcms */
19747         .ops = {
19748                 .prepare = alc680_capture_pcm_prepare,
19749                 .cleanup = alc680_capture_pcm_cleanup
19750         },
19751 };
19752
19753 static struct snd_kcontrol_new alc680_base_mixer[] = {
19754         /* output mixer control */
19755         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
19756         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
19757         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
19758         HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
19759         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x12, 0, HDA_INPUT),
19760         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
19761         HDA_CODEC_VOLUME("Line In Boost Volume", 0x19, 0, HDA_INPUT),
19762         { }
19763 };
19764
19765 static struct hda_bind_ctls alc680_bind_cap_vol = {
19766         .ops = &snd_hda_bind_vol,
19767         .values = {
19768                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19769                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19770                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19771                 0
19772         },
19773 };
19774
19775 static struct hda_bind_ctls alc680_bind_cap_switch = {
19776         .ops = &snd_hda_bind_sw,
19777         .values = {
19778                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19779                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19780                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19781                 0
19782         },
19783 };
19784
19785 static struct snd_kcontrol_new alc680_master_capture_mixer[] = {
19786         HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
19787         HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
19788         { } /* end */
19789 };
19790
19791 /*
19792  * generic initialization of ADC, input mixers and output mixers
19793  */
19794 static struct hda_verb alc680_init_verbs[] = {
19795         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19796         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19797         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19798
19799         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19800         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19801         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19802         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
19803         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
19804         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19805
19806         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19807         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19808         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19809         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19810         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19811
19812         {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT   | AC_USRSP_EN},
19813         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19814         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19815
19816         { }
19817 };
19818
19819 /* toggle speaker-output according to the hp-jack state */
19820 static void alc680_base_setup(struct hda_codec *codec)
19821 {
19822         struct alc_spec *spec = codec->spec;
19823
19824         spec->autocfg.hp_pins[0] = 0x16;
19825         spec->autocfg.speaker_pins[0] = 0x14;
19826         spec->autocfg.speaker_pins[1] = 0x15;
19827         spec->autocfg.num_inputs = 2;
19828         spec->autocfg.inputs[0].pin = 0x18;
19829         spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
19830         spec->autocfg.inputs[1].pin = 0x19;
19831         spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
19832 }
19833
19834 static void alc680_unsol_event(struct hda_codec *codec,
19835                                            unsigned int res)
19836 {
19837         if ((res >> 26) == ALC880_HP_EVENT)
19838                 alc_automute_amp(codec);
19839         if ((res >> 26) == ALC880_MIC_EVENT)
19840                 alc680_rec_autoswitch(codec);
19841 }
19842
19843 static void alc680_inithook(struct hda_codec *codec)
19844 {
19845         alc_automute_amp(codec);
19846         alc680_rec_autoswitch(codec);
19847 }
19848
19849 /* create input playback/capture controls for the given pin */
19850 static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
19851                                     const char *ctlname, int idx)
19852 {
19853         hda_nid_t dac;
19854         int err;
19855
19856         switch (nid) {
19857         case 0x14:
19858                 dac = 0x02;
19859                 break;
19860         case 0x15:
19861                 dac = 0x03;
19862                 break;
19863         case 0x16:
19864                 dac = 0x04;
19865                 break;
19866         default:
19867                 return 0;
19868         }
19869         if (spec->multiout.dac_nids[0] != dac &&
19870             spec->multiout.dac_nids[1] != dac) {
19871                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
19872                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
19873                                                       HDA_OUTPUT));
19874                 if (err < 0)
19875                         return err;
19876
19877                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
19878                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
19879
19880                 if (err < 0)
19881                         return err;
19882                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19883         }
19884
19885         return 0;
19886 }
19887
19888 /* add playback controls from the parsed DAC table */
19889 static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
19890                                              const struct auto_pin_cfg *cfg)
19891 {
19892         hda_nid_t nid;
19893         int err;
19894
19895         spec->multiout.dac_nids = spec->private_dac_nids;
19896
19897         nid = cfg->line_out_pins[0];
19898         if (nid) {
19899                 const char *name;
19900                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19901                         name = "Speaker";
19902                 else
19903                         name = "Front";
19904                 err = alc680_new_analog_output(spec, nid, name, 0);
19905                 if (err < 0)
19906                         return err;
19907         }
19908
19909         nid = cfg->speaker_pins[0];
19910         if (nid) {
19911                 err = alc680_new_analog_output(spec, nid, "Speaker", 0);
19912                 if (err < 0)
19913                         return err;
19914         }
19915         nid = cfg->hp_pins[0];
19916         if (nid) {
19917                 err = alc680_new_analog_output(spec, nid, "Headphone", 0);
19918                 if (err < 0)
19919                         return err;
19920         }
19921
19922         return 0;
19923 }
19924
19925 static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
19926                                               hda_nid_t nid, int pin_type)
19927 {
19928         alc_set_pin_output(codec, nid, pin_type);
19929 }
19930
19931 static void alc680_auto_init_multi_out(struct hda_codec *codec)
19932 {
19933         struct alc_spec *spec = codec->spec;
19934         hda_nid_t nid = spec->autocfg.line_out_pins[0];
19935         if (nid) {
19936                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
19937                 alc680_auto_set_output_and_unmute(codec, nid, pin_type);
19938         }
19939 }
19940
19941 static void alc680_auto_init_hp_out(struct hda_codec *codec)
19942 {
19943         struct alc_spec *spec = codec->spec;
19944         hda_nid_t pin;
19945
19946         pin = spec->autocfg.hp_pins[0];
19947         if (pin)
19948                 alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
19949         pin = spec->autocfg.speaker_pins[0];
19950         if (pin)
19951                 alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
19952 }
19953
19954 /* pcm configuration: identical with ALC880 */
19955 #define alc680_pcm_analog_playback      alc880_pcm_analog_playback
19956 #define alc680_pcm_analog_capture       alc880_pcm_analog_capture
19957 #define alc680_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
19958 #define alc680_pcm_digital_playback     alc880_pcm_digital_playback
19959 #define alc680_pcm_digital_capture      alc880_pcm_digital_capture
19960
19961 /*
19962  * BIOS auto configuration
19963  */
19964 static int alc680_parse_auto_config(struct hda_codec *codec)
19965 {
19966         struct alc_spec *spec = codec->spec;
19967         int err;
19968         static hda_nid_t alc680_ignore[] = { 0 };
19969
19970         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19971                                            alc680_ignore);
19972         if (err < 0)
19973                 return err;
19974
19975         if (!spec->autocfg.line_outs) {
19976                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
19977                         spec->multiout.max_channels = 2;
19978                         spec->no_analog = 1;
19979                         goto dig_only;
19980                 }
19981                 return 0; /* can't find valid BIOS pin config */
19982         }
19983         err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
19984         if (err < 0)
19985                 return err;
19986
19987         spec->multiout.max_channels = 2;
19988
19989  dig_only:
19990         /* digital only support output */
19991         alc_auto_parse_digital(codec);
19992         if (spec->kctls.list)
19993                 add_mixer(spec, spec->kctls.list);
19994
19995         add_verb(spec, alc680_init_verbs);
19996
19997         err = alc_auto_add_mic_boost(codec);
19998         if (err < 0)
19999                 return err;
20000
20001         return 1;
20002 }
20003
20004 #define alc680_auto_init_analog_input   alc882_auto_init_analog_input
20005
20006 /* init callback for auto-configuration model -- overriding the default init */
20007 static void alc680_auto_init(struct hda_codec *codec)
20008 {
20009         struct alc_spec *spec = codec->spec;
20010         alc680_auto_init_multi_out(codec);
20011         alc680_auto_init_hp_out(codec);
20012         alc680_auto_init_analog_input(codec);
20013         alc_auto_init_digital(codec);
20014         if (spec->unsol_event)
20015                 alc_inithook(codec);
20016 }
20017
20018 /*
20019  * configuration and preset
20020  */
20021 static const char * const alc680_models[ALC680_MODEL_LAST] = {
20022         [ALC680_BASE]           = "base",
20023         [ALC680_AUTO]           = "auto",
20024 };
20025
20026 static struct snd_pci_quirk alc680_cfg_tbl[] = {
20027         SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
20028         {}
20029 };
20030
20031 static struct alc_config_preset alc680_presets[] = {
20032         [ALC680_BASE] = {
20033                 .mixers = { alc680_base_mixer },
20034                 .cap_mixer =  alc680_master_capture_mixer,
20035                 .init_verbs = { alc680_init_verbs },
20036                 .num_dacs = ARRAY_SIZE(alc680_dac_nids),
20037                 .dac_nids = alc680_dac_nids,
20038                 .dig_out_nid = ALC680_DIGOUT_NID,
20039                 .num_channel_mode = ARRAY_SIZE(alc680_modes),
20040                 .channel_mode = alc680_modes,
20041                 .unsol_event = alc680_unsol_event,
20042                 .setup = alc680_base_setup,
20043                 .init_hook = alc680_inithook,
20044
20045         },
20046 };
20047
20048 static int patch_alc680(struct hda_codec *codec)
20049 {
20050         struct alc_spec *spec;
20051         int board_config;
20052         int err;
20053
20054         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
20055         if (spec == NULL)
20056                 return -ENOMEM;
20057
20058         codec->spec = spec;
20059
20060         board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
20061                                                   alc680_models,
20062                                                   alc680_cfg_tbl);
20063
20064         if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
20065                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
20066                        codec->chip_name);
20067                 board_config = ALC680_AUTO;
20068         }
20069
20070         if (board_config == ALC680_AUTO) {
20071                 /* automatic parse from the BIOS config */
20072                 err = alc680_parse_auto_config(codec);
20073                 if (err < 0) {
20074                         alc_free(codec);
20075                         return err;
20076                 } else if (!err) {
20077                         printk(KERN_INFO
20078                                "hda_codec: Cannot set up configuration "
20079                                "from BIOS.  Using base mode...\n");
20080                         board_config = ALC680_BASE;
20081                 }
20082         }
20083
20084         if (board_config != ALC680_AUTO)
20085                 setup_preset(codec, &alc680_presets[board_config]);
20086
20087         spec->stream_analog_playback = &alc680_pcm_analog_playback;
20088         spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
20089         spec->stream_digital_playback = &alc680_pcm_digital_playback;
20090         spec->stream_digital_capture = &alc680_pcm_digital_capture;
20091
20092         if (!spec->adc_nids) {
20093                 spec->adc_nids = alc680_adc_nids;
20094                 spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
20095         }
20096
20097         if (!spec->cap_mixer)
20098                 set_capture_mixer(codec);
20099
20100         spec->vmaster_nid = 0x02;
20101
20102         codec->patch_ops = alc_patch_ops;
20103         if (board_config == ALC680_AUTO)
20104                 spec->init_hook = alc680_auto_init;
20105
20106         return 0;
20107 }
20108
20109 /*
20110  * patch entries
20111  */
20112 static struct hda_codec_preset snd_hda_preset_realtek[] = {
20113         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
20114         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
20115         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
20116         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
20117         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
20118         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
20119         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
20120         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
20121         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
20122           .patch = patch_alc861 },
20123         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
20124         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
20125         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
20126         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
20127           .patch = patch_alc882 },
20128         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
20129           .patch = patch_alc662 },
20130         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
20131         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
20132         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
20133         { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
20134         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
20135         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
20136         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
20137         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
20138           .patch = patch_alc882 },
20139         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
20140           .patch = patch_alc882 },
20141         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
20142         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 },
20143         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
20144           .patch = patch_alc882 },
20145         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
20146         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
20147         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
20148         {} /* terminator */
20149 };
20150
20151 MODULE_ALIAS("snd-hda-codec-id:10ec*");
20152
20153 MODULE_LICENSE("GPL");
20154 MODULE_DESCRIPTION("Realtek HD-audio codec");
20155
20156 static struct hda_codec_preset_list realtek_list = {
20157         .preset = snd_hda_preset_realtek,
20158         .owner = THIS_MODULE,
20159 };
20160
20161 static int __init patch_realtek_init(void)
20162 {
20163         return snd_hda_add_codec_preset(&realtek_list);
20164 }
20165
20166 static void __exit patch_realtek_exit(void)
20167 {
20168         snd_hda_delete_codec_preset(&realtek_list);
20169 }
20170
20171 module_init(patch_realtek_init)
20172 module_exit(patch_realtek_exit)