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_spec {
 307         /* codec parameterization */
 308         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 309         unsigned int num_mixers;
 310         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 311         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 312
 313         const struct hda_verb *init_verbs[10];  /* initialization verbs
 314                                                  * don't forget NULL
 315                                                  * termination!
 316                                                  */
 317         unsigned int num_init_verbs;
 318
 319         char stream_name_analog[32];    /* analog PCM stream */
 320         struct hda_pcm_stream *stream_analog_playback;
 321         struct hda_pcm_stream *stream_analog_capture;
 322         struct hda_pcm_stream *stream_analog_alt_playback;
 323         struct hda_pcm_stream *stream_analog_alt_capture;
 324
 325         char stream_name_digital[32];   /* digital PCM stream */
 326         struct hda_pcm_stream *stream_digital_playback;
 327         struct hda_pcm_stream *stream_digital_capture;
 328
 329         /* playback */
 330         struct hda_multi_out multiout;  /* playback set-up
 331                                          * max_channels, dacs must be set
 332                                          * dig_out_nid and hp_nid are optional
 333                                          */
 334         hda_nid_t alt_dac_nid;
 335         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 336         int dig_out_type;
 337
 338         /* capture */
 339         unsigned int num_adc_nids;
 340         hda_nid_t *adc_nids;
 341         hda_nid_t *capsrc_nids;
 342         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 343
 344         /* capture setup for dynamic dual-adc switch */
 345         unsigned int cur_adc_idx;
 346         hda_nid_t cur_adc;
 347         unsigned int cur_adc_stream_tag;
 348         unsigned int cur_adc_format;
 349
 350         /* capture source */
 351         unsigned int num_mux_defs;
 352         const struct hda_input_mux *input_mux;
 353         unsigned int cur_mux[3];
 354         struct alc_mic_route ext_mic;
 355         struct alc_mic_route int_mic;
 356
 357         /* channel model */
 358         const struct hda_channel_mode *channel_mode;
 359         int num_channel_mode;
 360         int need_dac_fix;
 361         int const_channel_count;
 362         int ext_channel_count;
 363
 364         /* PCM information */
 365         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 366
 367         /* jack detection */
 368         struct snd_array jacks;
 369
 370         /* dynamic controls, init_verbs and input_mux */
 371         struct auto_pin_cfg autocfg;
 372         struct alc_customize_define cdefine;
 373         struct snd_array kctls;
 374         struct hda_input_mux private_imux[3];
 375         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 376         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 377         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 378
 379         /* hooks */
 380         void (*init_hook)(struct hda_codec *codec);
 381         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 382 #ifdef CONFIG_SND_HDA_POWER_SAVE
 383         void (*power_hook)(struct hda_codec *codec);
 384 #endif
 385
 386         /* for pin sensing */
 387         unsigned int sense_updated: 1;
 388         unsigned int jack_present: 1;
 389         unsigned int master_sw: 1;
 390         unsigned int auto_mic:1;
 391
 392         /* other flags */
 393         unsigned int no_analog :1; /* digital I/O only */
 394         unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */
 395         int init_amp;
 396         int codec_variant;      /* flag for other variants */
 397
 398         /* for virtual master */
 399         hda_nid_t vmaster_nid;
 400 #ifdef CONFIG_SND_HDA_POWER_SAVE
 401         struct hda_loopback_check loopback;
 402 #endif
 403
 404         /* for PLL fix */
 405         hda_nid_t pll_nid;
 406         unsigned int pll_coef_idx, pll_coef_bit;
 407 };
 408
 409 /*
 410  * configuration template - to be copied to the spec instance
 411  */
 412 struct alc_config_preset {
 413         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 414                                              * with spec
 415                                              */
 416         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 417         const struct hda_verb *init_verbs[5];
 418         unsigned int num_dacs;
 419         hda_nid_t *dac_nids;
 420         hda_nid_t dig_out_nid;          /* optional */
 421         hda_nid_t hp_nid;               /* optional */
 422         hda_nid_t *slave_dig_outs;
 423         unsigned int num_adc_nids;
 424         hda_nid_t *adc_nids;
 425         hda_nid_t *capsrc_nids;
 426         hda_nid_t dig_in_nid;
 427         unsigned int num_channel_mode;
 428         const struct hda_channel_mode *channel_mode;
 429         int need_dac_fix;
 430         int const_channel_count;
 431         unsigned int num_mux_defs;
 432         const struct hda_input_mux *input_mux;
 433         void (*unsol_event)(struct hda_codec *, unsigned int);
 434         void (*setup)(struct hda_codec *);
 435         void (*init_hook)(struct hda_codec *);
 436 #ifdef CONFIG_SND_HDA_POWER_SAVE
 437         struct hda_amp_list *loopbacks;
 438         void (*power_hook)(struct hda_codec *codec);
 439 #endif
 440 };
 441
 442
 443 /*
 444  * input MUX handling
 445  */
 446 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 447                              struct snd_ctl_elem_info *uinfo)
 448 {
 449         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 450         struct alc_spec *spec = codec->spec;
 451         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 452         if (mux_idx >= spec->num_mux_defs)
 453                 mux_idx = 0;
 454         if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
 455                 mux_idx = 0;
 456         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 457 }
 458
 459 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 460                             struct snd_ctl_elem_value *ucontrol)
 461 {
 462         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 463         struct alc_spec *spec = codec->spec;
 464         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 465
 466         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 467         return 0;
 468 }
 469
 470 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 471                             struct snd_ctl_elem_value *ucontrol)
 472 {
 473         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 474         struct alc_spec *spec = codec->spec;
 475         const struct hda_input_mux *imux;
 476         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 477         unsigned int mux_idx;
 478         hda_nid_t nid = spec->capsrc_nids ?
 479                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 480         unsigned int type;
 481
 482         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 483         imux = &spec->input_mux[mux_idx];
 484         if (!imux->num_items && mux_idx > 0)
 485                 imux = &spec->input_mux[0];
 486
 487         type = get_wcaps_type(get_wcaps(codec, nid));
 488         if (type == AC_WID_AUD_MIX) {
 489                 /* Matrix-mixer style (e.g. ALC882) */
 490                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 491                 unsigned int i, idx;
 492
 493                 idx = ucontrol->value.enumerated.item[0];
 494                 if (idx >= imux->num_items)
 495                         idx = imux->num_items - 1;
 496                 if (*cur_val == idx)
 497                         return 0;
 498                 for (i = 0; i < imux->num_items; i++) {
 499                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 500                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 501                                                  imux->items[i].index,
 502                                                  HDA_AMP_MUTE, v);
 503                 }
 504                 *cur_val = idx;
 505                 return 1;
 506         } else {
 507                 /* MUX style (e.g. ALC880) */
 508                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 509                                              &spec->cur_mux[adc_idx]);
 510         }
 511 }
 512
 513 /*
 514  * channel mode setting
 515  */
 516 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 517                             struct snd_ctl_elem_info *uinfo)
 518 {
 519         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 520         struct alc_spec *spec = codec->spec;
 521         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 522                                     spec->num_channel_mode);
 523 }
 524
 525 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 526                            struct snd_ctl_elem_value *ucontrol)
 527 {
 528         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 529         struct alc_spec *spec = codec->spec;
 530         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 531                                    spec->num_channel_mode,
 532                                    spec->ext_channel_count);
 533 }
 534
 535 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 536                            struct snd_ctl_elem_value *ucontrol)
 537 {
 538         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 539         struct alc_spec *spec = codec->spec;
 540         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 541                                       spec->num_channel_mode,
 542                                       &spec->ext_channel_count);
 543         if (err >= 0 && !spec->const_channel_count) {
 544                 spec->multiout.max_channels = spec->ext_channel_count;
 545                 if (spec->need_dac_fix)
 546                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 547         }
 548         return err;
 549 }
 550
 551 /*
 552  * Control the mode of pin widget settings via the mixer.  "pc" is used
 553  * instead of "%" to avoid consequences of accidently treating the % as
 554  * being part of a format specifier.  Maximum allowed length of a value is
 555  * 63 characters plus NULL terminator.
 556  *
 557  * Note: some retasking pin complexes seem to ignore requests for input
 558  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 559  * are requested.  Therefore order this list so that this behaviour will not
 560  * cause problems when mixer clients move through the enum sequentially.
 561  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 562  * March 2006.
 563  */
 564 static char *alc_pin_mode_names[] = {
 565         "Mic 50pc bias", "Mic 80pc bias",
 566         "Line in", "Line out", "Headphone out",
 567 };
 568 static unsigned char alc_pin_mode_values[] = {
 569         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 570 };
 571 /* The control can present all 5 options, or it can limit the options based
 572  * in the pin being assumed to be exclusively an input or an output pin.  In
 573  * addition, "input" pins may or may not process the mic bias option
 574  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 575  * accept requests for bias as of chip versions up to March 2006) and/or
 576  * wiring in the computer.
 577  */
 578 #define ALC_PIN_DIR_IN              0x00
 579 #define ALC_PIN_DIR_OUT             0x01
 580 #define ALC_PIN_DIR_INOUT           0x02
 581 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 582 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 583
 584 /* Info about the pin modes supported by the different pin direction modes.
 585  * For each direction the minimum and maximum values are given.
 586  */
 587 static signed char alc_pin_mode_dir_info[5][2] = {
 588         { 0, 2 },    /* ALC_PIN_DIR_IN */
 589         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 590         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 591         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 592         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 593 };
 594 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 595 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 596 #define alc_pin_mode_n_items(_dir) \
 597         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 598
 599 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 600                              struct snd_ctl_elem_info *uinfo)
 601 {
 602         unsigned int item_num = uinfo->value.enumerated.item;
 603         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 604
 605         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 606         uinfo->count = 1;
 607         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 608
 609         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 610                 item_num = alc_pin_mode_min(dir);
 611         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 612         return 0;
 613 }
 614
 615 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 616                             struct snd_ctl_elem_value *ucontrol)
 617 {
 618         unsigned int i;
 619         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 620         hda_nid_t nid = kcontrol->private_value & 0xffff;
 621         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 622         long *valp = ucontrol->value.integer.value;
 623         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 624                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 625                                                  0x00);
 626
 627         /* Find enumerated value for current pinctl setting */
 628         i = alc_pin_mode_min(dir);
 629         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 630                 i++;
 631         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 632         return 0;
 633 }
 634
 635 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 636                             struct snd_ctl_elem_value *ucontrol)
 637 {
 638         signed int change;
 639         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 640         hda_nid_t nid = kcontrol->private_value & 0xffff;
 641         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 642         long val = *ucontrol->value.integer.value;
 643         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 644                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 645                                                  0x00);
 646
 647         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 648                 val = alc_pin_mode_min(dir);
 649
 650         change = pinctl != alc_pin_mode_values[val];
 651         if (change) {
 652                 /* Set pin mode to that requested */
 653                 snd_hda_codec_write_cache(codec, nid, 0,
 654                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 655                                           alc_pin_mode_values[val]);
 656
 657                 /* Also enable the retasking pin's input/output as required
 658                  * for the requested pin mode.  Enum values of 2 or less are
 659                  * input modes.
 660                  *
 661                  * Dynamically switching the input/output buffers probably
 662                  * reduces noise slightly (particularly on input) so we'll
 663                  * do it.  However, having both input and output buffers
 664                  * enabled simultaneously doesn't seem to be problematic if
 665                  * this turns out to be necessary in the future.
 666                  */
 667                 if (val <= 2) {
 668                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 669                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 670                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 671                                                  HDA_AMP_MUTE, 0);
 672                 } else {
 673                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 674                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 675                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 676                                                  HDA_AMP_MUTE, 0);
 677                 }
 678         }
 679         return change;
 680 }
 681
 682 #define ALC_PIN_MODE(xname, nid, dir) \
 683         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 684           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 685           .info = alc_pin_mode_info, \
 686           .get = alc_pin_mode_get, \
 687           .put = alc_pin_mode_put, \
 688           .private_value = nid | (dir<<16) }
 689
 690 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 691  * together using a mask with more than one bit set.  This control is
 692  * currently used only by the ALC260 test model.  At this stage they are not
 693  * needed for any "production" models.
 694  */
 695 #ifdef CONFIG_SND_DEBUG
 696 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 697
 698 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 699                              struct snd_ctl_elem_value *ucontrol)
 700 {
 701         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 702         hda_nid_t nid = kcontrol->private_value & 0xffff;
 703         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 704         long *valp = ucontrol->value.integer.value;
 705         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 706                                               AC_VERB_GET_GPIO_DATA, 0x00);
 707
 708         *valp = (val & mask) != 0;
 709         return 0;
 710 }
 711 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 712                              struct snd_ctl_elem_value *ucontrol)
 713 {
 714         signed int change;
 715         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 716         hda_nid_t nid = kcontrol->private_value & 0xffff;
 717         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 718         long val = *ucontrol->value.integer.value;
 719         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 720                                                     AC_VERB_GET_GPIO_DATA,
 721                                                     0x00);
 722
 723         /* Set/unset the masked GPIO bit(s) as needed */
 724         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 725         if (val == 0)
 726                 gpio_data &= ~mask;
 727         else
 728                 gpio_data |= mask;
 729         snd_hda_codec_write_cache(codec, nid, 0,
 730                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 731
 732         return change;
 733 }
 734 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 735         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 736           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 737           .info = alc_gpio_data_info, \
 738           .get = alc_gpio_data_get, \
 739           .put = alc_gpio_data_put, \
 740           .private_value = nid | (mask<<16) }
 741 #endif   /* CONFIG_SND_DEBUG */
 742
 743 /* A switch control to allow the enabling of the digital IO pins on the
 744  * ALC260.  This is incredibly simplistic; the intention of this control is
 745  * to provide something in the test model allowing digital outputs to be
 746  * identified if present.  If models are found which can utilise these
 747  * outputs a more complete mixer control can be devised for those models if
 748  * necessary.
 749  */
 750 #ifdef CONFIG_SND_DEBUG
 751 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 752
 753 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 754                               struct snd_ctl_elem_value *ucontrol)
 755 {
 756         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 757         hda_nid_t nid = kcontrol->private_value & 0xffff;
 758         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 759         long *valp = ucontrol->value.integer.value;
 760         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 761                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 762
 763         *valp = (val & mask) != 0;
 764         return 0;
 765 }
 766 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 767                               struct snd_ctl_elem_value *ucontrol)
 768 {
 769         signed int change;
 770         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 771         hda_nid_t nid = kcontrol->private_value & 0xffff;
 772         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 773         long val = *ucontrol->value.integer.value;
 774         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 775                                                     AC_VERB_GET_DIGI_CONVERT_1,
 776                                                     0x00);
 777
 778         /* Set/unset the masked control bit(s) as needed */
 779         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 780         if (val==0)
 781                 ctrl_data &= ~mask;
 782         else
 783                 ctrl_data |= mask;
 784         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 785                                   ctrl_data);
 786
 787         return change;
 788 }
 789 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 790         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 791           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 792           .info = alc_spdif_ctrl_info, \
 793           .get = alc_spdif_ctrl_get, \
 794           .put = alc_spdif_ctrl_put, \
 795           .private_value = nid | (mask<<16) }
 796 #endif   /* CONFIG_SND_DEBUG */
 797
 798 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 799  * Again, this is only used in the ALC26x test models to help identify when
 800  * the EAPD line must be asserted for features to work.
 801  */
 802 #ifdef CONFIG_SND_DEBUG
 803 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 804
 805 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 806                               struct snd_ctl_elem_value *ucontrol)
 807 {
 808         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 809         hda_nid_t nid = kcontrol->private_value & 0xffff;
 810         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 811         long *valp = ucontrol->value.integer.value;
 812         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 813                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 814
 815         *valp = (val & mask) != 0;
 816         return 0;
 817 }
 818
 819 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 820                               struct snd_ctl_elem_value *ucontrol)
 821 {
 822         int change;
 823         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 824         hda_nid_t nid = kcontrol->private_value & 0xffff;
 825         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 826         long val = *ucontrol->value.integer.value;
 827         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 828                                                     AC_VERB_GET_EAPD_BTLENABLE,
 829                                                     0x00);
 830
 831         /* Set/unset the masked control bit(s) as needed */
 832         change = (!val ? 0 : mask) != (ctrl_data & mask);
 833         if (!val)
 834                 ctrl_data &= ~mask;
 835         else
 836                 ctrl_data |= mask;
 837         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 838                                   ctrl_data);
 839
 840         return change;
 841 }
 842
 843 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 844         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 845           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 846           .info = alc_eapd_ctrl_info, \
 847           .get = alc_eapd_ctrl_get, \
 848           .put = alc_eapd_ctrl_put, \
 849           .private_value = nid | (mask<<16) }
 850 #endif   /* CONFIG_SND_DEBUG */
 851
 852 /*
 853  * set up the input pin config (depending on the given auto-pin type)
 854  */
 855 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 856                               int auto_pin_type)
 857 {
 858         unsigned int val = PIN_IN;
 859
 860         if (auto_pin_type == AUTO_PIN_MIC) {
 861                 unsigned int pincap;
 862                 unsigned int oldval;
 863                 oldval = snd_hda_codec_read(codec, nid, 0,
 864                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 865                 pincap = snd_hda_query_pin_caps(codec, nid);
 866                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 867                 /* if the default pin setup is vref50, we give it priority */
 868                 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
 869                         val = PIN_VREF80;
 870                 else if (pincap & AC_PINCAP_VREF_50)
 871                         val = PIN_VREF50;
 872                 else if (pincap & AC_PINCAP_VREF_100)
 873                         val = PIN_VREF100;
 874                 else if (pincap & AC_PINCAP_VREF_GRD)
 875                         val = PIN_VREFGRD;
 876         }
 877         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 878 }
 879
 880 static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec)
 881 {
 882         struct alc_spec *spec = codec->spec;
 883         struct auto_pin_cfg *cfg = &spec->autocfg;
 884
 885         if (!cfg->line_outs) {
 886                 while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
 887                        cfg->line_out_pins[cfg->line_outs])
 888                         cfg->line_outs++;
 889         }
 890         if (!cfg->speaker_outs) {
 891                 while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
 892                        cfg->speaker_pins[cfg->speaker_outs])
 893                         cfg->speaker_outs++;
 894         }
 895         if (!cfg->hp_outs) {
 896                 while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
 897                        cfg->hp_pins[cfg->hp_outs])
 898                         cfg->hp_outs++;
 899         }
 900 }
 901
 902 /*
 903  */
 904 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 905 {
 906         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 907                 return;
 908         spec->mixers[spec->num_mixers++] = mix;
 909 }
 910
 911 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 912 {
 913         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 914                 return;
 915         spec->init_verbs[spec->num_init_verbs++] = verb;
 916 }
 917
 918 /*
 919  * set up from the preset table
 920  */
 921 static void setup_preset(struct hda_codec *codec,
 922                          const struct alc_config_preset *preset)
 923 {
 924         struct alc_spec *spec = codec->spec;
 925         int i;
 926
 927         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 928                 add_mixer(spec, preset->mixers[i]);
 929         spec->cap_mixer = preset->cap_mixer;
 930         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 931              i++)
 932                 add_verb(spec, preset->init_verbs[i]);
 933
 934         spec->channel_mode = preset->channel_mode;
 935         spec->num_channel_mode = preset->num_channel_mode;
 936         spec->need_dac_fix = preset->need_dac_fix;
 937         spec->const_channel_count = preset->const_channel_count;
 938
 939         if (preset->const_channel_count)
 940                 spec->multiout.max_channels = preset->const_channel_count;
 941         else
 942                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 943         spec->ext_channel_count = spec->channel_mode[0].channels;
 944
 945         spec->multiout.num_dacs = preset->num_dacs;
 946         spec->multiout.dac_nids = preset->dac_nids;
 947         spec->multiout.dig_out_nid = preset->dig_out_nid;
 948         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 949         spec->multiout.hp_nid = preset->hp_nid;
 950
 951         spec->num_mux_defs = preset->num_mux_defs;
 952         if (!spec->num_mux_defs)
 953                 spec->num_mux_defs = 1;
 954         spec->input_mux = preset->input_mux;
 955
 956         spec->num_adc_nids = preset->num_adc_nids;
 957         spec->adc_nids = preset->adc_nids;
 958         spec->capsrc_nids = preset->capsrc_nids;
 959         spec->dig_in_nid = preset->dig_in_nid;
 960
 961         spec->unsol_event = preset->unsol_event;
 962         spec->init_hook = preset->init_hook;
 963 #ifdef CONFIG_SND_HDA_POWER_SAVE
 964         spec->power_hook = preset->power_hook;
 965         spec->loopback.amplist = preset->loopbacks;
 966 #endif
 967
 968         if (preset->setup)
 969                 preset->setup(codec);
 970
 971         alc_fixup_autocfg_pin_nums(codec);
 972 }
 973
 974 /* Enable GPIO mask and set output */
 975 static struct hda_verb alc_gpio1_init_verbs[] = {
 976         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 977         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 978         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 979         { }
 980 };
 981
 982 static struct hda_verb alc_gpio2_init_verbs[] = {
 983         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 984         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 985         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 986         { }
 987 };
 988
 989 static struct hda_verb alc_gpio3_init_verbs[] = {
 990         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 991         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 992         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 993         { }
 994 };
 995
 996 /*
 997  * Fix hardware PLL issue
 998  * On some codecs, the analog PLL gating control must be off while
 999  * the default value is 1.
1000  */
1001 static void alc_fix_pll(struct hda_codec *codec)
1002 {
1003         struct alc_spec *spec = codec->spec;
1004         unsigned int val;
1005
1006         if (!spec->pll_nid)
1007                 return;
1008         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1009                             spec->pll_coef_idx);
1010         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
1011                                  AC_VERB_GET_PROC_COEF, 0);
1012         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1013                             spec->pll_coef_idx);
1014         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
1015                             val & ~(1 << spec->pll_coef_bit));
1016 }
1017
1018 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
1019                              unsigned int coef_idx, unsigned int coef_bit)
1020 {
1021         struct alc_spec *spec = codec->spec;
1022         spec->pll_nid = nid;
1023         spec->pll_coef_idx = coef_idx;
1024         spec->pll_coef_bit = coef_bit;
1025         alc_fix_pll(codec);
1026 }
1027
1028 #ifdef CONFIG_SND_HDA_INPUT_JACK
1029 static void alc_free_jack_priv(struct snd_jack *jack)
1030 {
1031         struct alc_jack *jacks = jack->private_data;
1032         jacks->nid = 0;
1033         jacks->jack = NULL;
1034 }
1035
1036 static int alc_add_jack(struct hda_codec *codec,
1037                 hda_nid_t nid, int type)
1038 {
1039         struct alc_spec *spec;
1040         struct alc_jack *jack;
1041         const char *name;
1042         int err;
1043
1044         spec = codec->spec;
1045         snd_array_init(&spec->jacks, sizeof(*jack), 32);
1046         jack = snd_array_new(&spec->jacks);
1047         if (!jack)
1048                 return -ENOMEM;
1049
1050         jack->nid = nid;
1051         jack->type = type;
1052         name = (type == SND_JACK_HEADPHONE) ? "Headphone" : "Mic" ;
1053
1054         err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
1055         if (err < 0)
1056                 return err;
1057         jack->jack->private_data = jack;
1058         jack->jack->private_free = alc_free_jack_priv;
1059         return 0;
1060 }
1061
1062 static void alc_report_jack(struct hda_codec *codec, hda_nid_t nid)
1063 {
1064         struct alc_spec *spec = codec->spec;
1065         struct alc_jack *jacks = spec->jacks.list;
1066
1067         if (jacks) {
1068                 int i;
1069                 for (i = 0; i < spec->jacks.used; i++) {
1070                         if (jacks->nid == nid) {
1071                                 unsigned int present;
1072                                 present = snd_hda_jack_detect(codec, nid);
1073
1074                                 present = (present) ? jacks->type : 0;
1075
1076                                 snd_jack_report(jacks->jack, present);
1077                         }
1078                         jacks++;
1079                 }
1080         }
1081 }
1082
1083 static int alc_init_jacks(struct hda_codec *codec)
1084 {
1085         struct alc_spec *spec = codec->spec;
1086         int err;
1087         unsigned int hp_nid = spec->autocfg.hp_pins[0];
1088         unsigned int mic_nid = spec->ext_mic.pin;
1089
1090         if (hp_nid) {
1091                 err = alc_add_jack(codec, hp_nid, SND_JACK_HEADPHONE);
1092                 if (err < 0)
1093                         return err;
1094                 alc_report_jack(codec, hp_nid);
1095         }
1096
1097         if (mic_nid) {
1098                 err = alc_add_jack(codec, mic_nid, SND_JACK_MICROPHONE);
1099                 if (err < 0)
1100                         return err;
1101                 alc_report_jack(codec, mic_nid);
1102         }
1103
1104         return 0;
1105 }
1106 #else
1107 static inline void alc_report_jack(struct hda_codec *codec, hda_nid_t nid)
1108 {
1109 }
1110
1111 static inline int alc_init_jacks(struct hda_codec *codec)
1112 {
1113         return 0;
1114 }
1115 #endif
1116
1117 static void alc_automute_speaker(struct hda_codec *codec, int pinctl)
1118 {
1119         struct alc_spec *spec = codec->spec;
1120         unsigned int mute;
1121         hda_nid_t nid;
1122         int i;
1123
1124         spec->jack_present = 0;
1125         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1126                 nid = spec->autocfg.hp_pins[i];
1127                 if (!nid)
1128                         break;
1129                 if (snd_hda_jack_detect(codec, nid)) {
1130                         spec->jack_present = 1;
1131                         break;
1132                 }
1133                 alc_report_jack(codec, spec->autocfg.hp_pins[i]);
1134         }
1135
1136         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1137         /* Toggle internal speakers muting */
1138         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1139                 nid = spec->autocfg.speaker_pins[i];
1140                 if (!nid)
1141                         break;
1142                 if (pinctl) {
1143                         snd_hda_codec_write(codec, nid, 0,
1144                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1145                                     spec->jack_present ? 0 : PIN_OUT);
1146                 } else {
1147                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1148                                          HDA_AMP_MUTE, mute);
1149                 }
1150         }
1151 }
1152
1153 static void alc_automute_pin(struct hda_codec *codec)
1154 {
1155         alc_automute_speaker(codec, 1);
1156 }
1157
1158 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
1159                                 hda_nid_t nid)
1160 {
1161         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
1162         int i, nums;
1163
1164         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
1165         for (i = 0; i < nums; i++)
1166                 if (conn[i] == nid)
1167                         return i;
1168         return -1;
1169 }
1170
1171 /* switch the current ADC according to the jack state */
1172 static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec)
1173 {
1174         struct alc_spec *spec = codec->spec;
1175         unsigned int present;
1176         hda_nid_t new_adc;
1177
1178         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1179         if (present)
1180                 spec->cur_adc_idx = 1;
1181         else
1182                 spec->cur_adc_idx = 0;
1183         new_adc = spec->adc_nids[spec->cur_adc_idx];
1184         if (spec->cur_adc && spec->cur_adc != new_adc) {
1185                 /* stream is running, let's swap the current ADC */
1186                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1187                 spec->cur_adc = new_adc;
1188                 snd_hda_codec_setup_stream(codec, new_adc,
1189                                            spec->cur_adc_stream_tag, 0,
1190                                            spec->cur_adc_format);
1191         }
1192 }
1193
1194 static void alc_mic_automute(struct hda_codec *codec)
1195 {
1196         struct alc_spec *spec = codec->spec;
1197         struct alc_mic_route *dead, *alive;
1198         unsigned int present, type;
1199         hda_nid_t cap_nid;
1200
1201         if (!spec->auto_mic)
1202                 return;
1203         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1204                 return;
1205         if (snd_BUG_ON(!spec->adc_nids))
1206                 return;
1207
1208         if (spec->dual_adc_switch) {
1209                 alc_dual_mic_adc_auto_switch(codec);
1210                 return;
1211         }
1212
1213         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1214
1215         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1216         if (present) {
1217                 alive = &spec->ext_mic;
1218                 dead = &spec->int_mic;
1219         } else {
1220                 alive = &spec->int_mic;
1221                 dead = &spec->ext_mic;
1222         }
1223
1224         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1225         if (type == AC_WID_AUD_MIX) {
1226                 /* Matrix-mixer style (e.g. ALC882) */
1227                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1228                                          alive->mux_idx,
1229                                          HDA_AMP_MUTE, 0);
1230                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1231                                          dead->mux_idx,
1232                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1233         } else {
1234                 /* MUX style (e.g. ALC880) */
1235                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1236                                           AC_VERB_SET_CONNECT_SEL,
1237                                           alive->mux_idx);
1238         }
1239         alc_report_jack(codec, spec->ext_mic.pin);
1240
1241         /* FIXME: analog mixer */
1242 }
1243
1244 /* unsolicited event for HP jack sensing */
1245 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1246 {
1247         if (codec->vendor_id == 0x10ec0880)
1248                 res >>= 28;
1249         else
1250                 res >>= 26;
1251         switch (res) {
1252         case ALC880_HP_EVENT:
1253                 alc_automute_pin(codec);
1254                 break;
1255         case ALC880_MIC_EVENT:
1256                 alc_mic_automute(codec);
1257                 break;
1258         }
1259 }
1260
1261 static void alc_inithook(struct hda_codec *codec)
1262 {
1263         alc_automute_pin(codec);
1264         alc_mic_automute(codec);
1265 }
1266
1267 /* additional initialization for ALC888 variants */
1268 static void alc888_coef_init(struct hda_codec *codec)
1269 {
1270         unsigned int tmp;
1271
1272         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1273         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1274         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1275         if ((tmp & 0xf0) == 0x20)
1276                 /* alc888S-VC */
1277                 snd_hda_codec_read(codec, 0x20, 0,
1278                                    AC_VERB_SET_PROC_COEF, 0x830);
1279          else
1280                  /* alc888-VB */
1281                  snd_hda_codec_read(codec, 0x20, 0,
1282                                     AC_VERB_SET_PROC_COEF, 0x3030);
1283 }
1284
1285 static void alc889_coef_init(struct hda_codec *codec)
1286 {
1287         unsigned int tmp;
1288
1289         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1290         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1291         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1292         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1293 }
1294
1295 /* turn on/off EAPD control (only if available) */
1296 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1297 {
1298         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1299                 return;
1300         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1301                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1302                                     on ? 2 : 0);
1303 }
1304
1305 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1306 {
1307         unsigned int tmp;
1308
1309         switch (type) {
1310         case ALC_INIT_GPIO1:
1311                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1312                 break;
1313         case ALC_INIT_GPIO2:
1314                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1315                 break;
1316         case ALC_INIT_GPIO3:
1317                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1318                 break;
1319         case ALC_INIT_DEFAULT:
1320                 switch (codec->vendor_id) {
1321                 case 0x10ec0260:
1322                         set_eapd(codec, 0x0f, 1);
1323                         set_eapd(codec, 0x10, 1);
1324                         break;
1325                 case 0x10ec0262:
1326                 case 0x10ec0267:
1327                 case 0x10ec0268:
1328                 case 0x10ec0269:
1329                 case 0x10ec0270:
1330                 case 0x10ec0272:
1331                 case 0x10ec0660:
1332                 case 0x10ec0662:
1333                 case 0x10ec0663:
1334                 case 0x10ec0862:
1335                 case 0x10ec0889:
1336                         set_eapd(codec, 0x14, 1);
1337                         set_eapd(codec, 0x15, 1);
1338                         break;
1339                 }
1340                 switch (codec->vendor_id) {
1341                 case 0x10ec0260:
1342                         snd_hda_codec_write(codec, 0x1a, 0,
1343                                             AC_VERB_SET_COEF_INDEX, 7);
1344                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1345                                                  AC_VERB_GET_PROC_COEF, 0);
1346                         snd_hda_codec_write(codec, 0x1a, 0,
1347                                             AC_VERB_SET_COEF_INDEX, 7);
1348                         snd_hda_codec_write(codec, 0x1a, 0,
1349                                             AC_VERB_SET_PROC_COEF,
1350                                             tmp | 0x2010);
1351                         break;
1352                 case 0x10ec0262:
1353                 case 0x10ec0880:
1354                 case 0x10ec0882:
1355                 case 0x10ec0883:
1356                 case 0x10ec0885:
1357                 case 0x10ec0887:
1358                 case 0x10ec0889:
1359                         alc889_coef_init(codec);
1360                         break;
1361                 case 0x10ec0888:
1362                         alc888_coef_init(codec);
1363                         break;
1364 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
1365                 case 0x10ec0267:
1366                 case 0x10ec0268:
1367                         snd_hda_codec_write(codec, 0x20, 0,
1368                                             AC_VERB_SET_COEF_INDEX, 7);
1369                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1370                                                  AC_VERB_GET_PROC_COEF, 0);
1371                         snd_hda_codec_write(codec, 0x20, 0,
1372                                             AC_VERB_SET_COEF_INDEX, 7);
1373                         snd_hda_codec_write(codec, 0x20, 0,
1374                                             AC_VERB_SET_PROC_COEF,
1375                                             tmp | 0x3000);
1376                         break;
1377 #endif /* XXX */
1378                 }
1379                 break;
1380         }
1381 }
1382
1383 static void alc_init_auto_hp(struct hda_codec *codec)
1384 {
1385         struct alc_spec *spec = codec->spec;
1386         struct auto_pin_cfg *cfg = &spec->autocfg;
1387         int i;
1388
1389         if (!cfg->hp_pins[0]) {
1390                 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1391                         return;
1392         }
1393
1394         if (!cfg->speaker_pins[0]) {
1395                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1396                         return;
1397                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1398                        sizeof(cfg->speaker_pins));
1399                 cfg->speaker_outs = cfg->line_outs;
1400         }
1401
1402         if (!cfg->hp_pins[0]) {
1403                 memcpy(cfg->hp_pins, cfg->line_out_pins,
1404                        sizeof(cfg->hp_pins));
1405                 cfg->hp_outs = cfg->line_outs;
1406         }
1407
1408         for (i = 0; i < cfg->hp_outs; i++) {
1409                 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1410                             cfg->hp_pins[i]);
1411                 snd_hda_codec_write_cache(codec, cfg->hp_pins[i], 0,
1412                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1413                                   AC_USRSP_EN | ALC880_HP_EVENT);
1414         }
1415         spec->unsol_event = alc_sku_unsol_event;
1416 }
1417
1418 static void alc_init_auto_mic(struct hda_codec *codec)
1419 {
1420         struct alc_spec *spec = codec->spec;
1421         struct auto_pin_cfg *cfg = &spec->autocfg;
1422         hda_nid_t fixed, ext;
1423         int i;
1424
1425         /* there must be only two mic inputs exclusively */
1426         for (i = 0; i < cfg->num_inputs; i++)
1427                 if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN)
1428                         return;
1429
1430         fixed = ext = 0;
1431         for (i = 0; i < cfg->num_inputs; i++) {
1432                 hda_nid_t nid = cfg->inputs[i].pin;
1433                 unsigned int defcfg;
1434                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1435                 switch (snd_hda_get_input_pin_attr(defcfg)) {
1436                 case INPUT_PIN_ATTR_INT:
1437                         if (fixed)
1438                                 return; /* already occupied */
1439                         fixed = nid;
1440                         break;
1441                 case INPUT_PIN_ATTR_UNUSED:
1442                         return; /* invalid entry */
1443                 default:
1444                         if (ext)
1445                                 return; /* already occupied */
1446                         ext = nid;
1447                         break;
1448                 }
1449         }
1450         if (!ext || !fixed)
1451                 return;
1452         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1453                 return; /* no unsol support */
1454         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1455                     ext, fixed);
1456         spec->ext_mic.pin = ext;
1457         spec->int_mic.pin = fixed;
1458         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1459         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1460         spec->auto_mic = 1;
1461         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1462                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1463                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1464         spec->unsol_event = alc_sku_unsol_event;
1465 }
1466
1467 /* Could be any non-zero and even value. When used as fixup, tells
1468  * the driver to ignore any present sku defines.
1469  */
1470 #define ALC_FIXUP_SKU_IGNORE (2)
1471
1472 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1473 {
1474         unsigned int ass, tmp, i;
1475         unsigned nid = 0;
1476         struct alc_spec *spec = codec->spec;
1477
1478         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1479
1480         if (spec->cdefine.fixup) {
1481                 ass = spec->cdefine.sku_cfg;
1482                 if (ass == ALC_FIXUP_SKU_IGNORE)
1483                         return -1;
1484                 goto do_sku;
1485         }
1486
1487         ass = codec->subsystem_id & 0xffff;
1488         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1489                 goto do_sku;
1490
1491         nid = 0x1d;
1492         if (codec->vendor_id == 0x10ec0260)
1493                 nid = 0x17;
1494         ass = snd_hda_codec_get_pincfg(codec, nid);
1495
1496         if (!(ass & 1)) {
1497                 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1498                        codec->chip_name, ass);
1499                 return -1;
1500         }
1501
1502         /* check sum */
1503         tmp = 0;
1504         for (i = 1; i < 16; i++) {
1505                 if ((ass >> i) & 1)
1506                         tmp++;
1507         }
1508         if (((ass >> 16) & 0xf) != tmp)
1509                 return -1;
1510
1511         spec->cdefine.port_connectivity = ass >> 30;
1512         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1513         spec->cdefine.check_sum = (ass >> 16) & 0xf;
1514         spec->cdefine.customization = ass >> 8;
1515 do_sku:
1516         spec->cdefine.sku_cfg = ass;
1517         spec->cdefine.external_amp = (ass & 0x38) >> 3;
1518         spec->cdefine.platform_type = (ass & 0x4) >> 2;
1519         spec->cdefine.swap = (ass & 0x2) >> 1;
1520         spec->cdefine.override = ass & 0x1;
1521
1522         snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1523                    nid, spec->cdefine.sku_cfg);
1524         snd_printd("SKU: port_connectivity=0x%x\n",
1525                    spec->cdefine.port_connectivity);
1526         snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1527         snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1528         snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1529         snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1530         snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1531         snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1532         snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1533
1534         return 0;
1535 }
1536
1537 /* check subsystem ID and set up device-specific initialization;
1538  * return 1 if initialized, 0 if invalid SSID
1539  */
1540 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1541  *      31 ~ 16 :       Manufacture ID
1542  *      15 ~ 8  :       SKU ID
1543  *      7  ~ 0  :       Assembly ID
1544  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1545  */
1546 static int alc_subsystem_id(struct hda_codec *codec,
1547                             hda_nid_t porta, hda_nid_t porte,
1548                             hda_nid_t portd, hda_nid_t porti)
1549 {
1550         unsigned int ass, tmp, i;
1551         unsigned nid;
1552         struct alc_spec *spec = codec->spec;
1553
1554         if (spec->cdefine.fixup) {
1555                 ass = spec->cdefine.sku_cfg;
1556                 if (ass == ALC_FIXUP_SKU_IGNORE)
1557                         return 0;
1558                 goto do_sku;
1559         }
1560
1561         ass = codec->subsystem_id & 0xffff;
1562         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1563                 goto do_sku;
1564
1565         /* invalid SSID, check the special NID pin defcfg instead */
1566         /*
1567          * 31~30        : port connectivity
1568          * 29~21        : reserve
1569          * 20           : PCBEEP input
1570          * 19~16        : Check sum (15:1)
1571          * 15~1         : Custom
1572          * 0            : override
1573         */
1574         nid = 0x1d;
1575         if (codec->vendor_id == 0x10ec0260)
1576                 nid = 0x17;
1577         ass = snd_hda_codec_get_pincfg(codec, nid);
1578         snd_printd("realtek: No valid SSID, "
1579                    "checking pincfg 0x%08x for NID 0x%x\n",
1580                    ass, nid);
1581         if (!(ass & 1))
1582                 return 0;
1583         if ((ass >> 30) != 1)   /* no physical connection */
1584                 return 0;
1585
1586         /* check sum */
1587         tmp = 0;
1588         for (i = 1; i < 16; i++) {
1589                 if ((ass >> i) & 1)
1590                         tmp++;
1591         }
1592         if (((ass >> 16) & 0xf) != tmp)
1593                 return 0;
1594 do_sku:
1595         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1596                    ass & 0xffff, codec->vendor_id);
1597         /*
1598          * 0 : override
1599          * 1 :  Swap Jack
1600          * 2 : 0 --> Desktop, 1 --> Laptop
1601          * 3~5 : External Amplifier control
1602          * 7~6 : Reserved
1603         */
1604         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1605         switch (tmp) {
1606         case 1:
1607                 spec->init_amp = ALC_INIT_GPIO1;
1608                 break;
1609         case 3:
1610                 spec->init_amp = ALC_INIT_GPIO2;
1611                 break;
1612         case 7:
1613                 spec->init_amp = ALC_INIT_GPIO3;
1614                 break;
1615         case 5:
1616         default:
1617                 spec->init_amp = ALC_INIT_DEFAULT;
1618                 break;
1619         }
1620
1621         /* is laptop or Desktop and enable the function "Mute internal speaker
1622          * when the external headphone out jack is plugged"
1623          */
1624         if (!(ass & 0x8000))
1625                 return 1;
1626         /*
1627          * 10~8 : Jack location
1628          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1629          * 14~13: Resvered
1630          * 15   : 1 --> enable the function "Mute internal speaker
1631          *              when the external headphone out jack is plugged"
1632          */
1633         if (!spec->autocfg.hp_pins[0]) {
1634                 hda_nid_t nid;
1635                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1636                 if (tmp == 0)
1637                         nid = porta;
1638                 else if (tmp == 1)
1639                         nid = porte;
1640                 else if (tmp == 2)
1641                         nid = portd;
1642                 else if (tmp == 3)
1643                         nid = porti;
1644                 else
1645                         return 1;
1646                 for (i = 0; i < spec->autocfg.line_outs; i++)
1647                         if (spec->autocfg.line_out_pins[i] == nid)
1648                                 return 1;
1649                 spec->autocfg.hp_pins[0] = nid;
1650         }
1651
1652         alc_init_auto_hp(codec);
1653         alc_init_auto_mic(codec);
1654         return 1;
1655 }
1656
1657 static void alc_ssid_check(struct hda_codec *codec,
1658                            hda_nid_t porta, hda_nid_t porte,
1659                            hda_nid_t portd, hda_nid_t porti)
1660 {
1661         if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1662                 struct alc_spec *spec = codec->spec;
1663                 snd_printd("realtek: "
1664                            "Enable default setup for auto mode as fallback\n");
1665                 spec->init_amp = ALC_INIT_DEFAULT;
1666                 alc_init_auto_hp(codec);
1667                 alc_init_auto_mic(codec);
1668         }
1669 }
1670
1671 /*
1672  * Fix-up pin default configurations and add default verbs
1673  */
1674
1675 struct alc_pincfg {
1676         hda_nid_t nid;
1677         u32 val;
1678 };
1679
1680 struct alc_model_fixup {
1681         const int id;
1682         const char *name;
1683 };
1684
1685 struct alc_fixup {
1686         unsigned int sku;
1687         const struct alc_pincfg *pins;
1688         const struct hda_verb *verbs;
1689         void (*func)(struct hda_codec *codec, const struct alc_fixup *fix,
1690                      int pre_init);
1691 };
1692
1693 static void __alc_pick_fixup(struct hda_codec *codec,
1694                              const struct alc_fixup *fix,
1695                              const char *modelname,
1696                              int pre_init)
1697 {
1698         const struct alc_pincfg *cfg;
1699         struct alc_spec *spec;
1700
1701         cfg = fix->pins;
1702         if (pre_init && fix->sku) {
1703 #ifdef CONFIG_SND_DEBUG_VERBOSE
1704                 snd_printdd(KERN_INFO "hda_codec: %s: Apply sku override for %s\n",
1705                             codec->chip_name, modelname);
1706 #endif
1707                 spec = codec->spec;
1708                 spec->cdefine.sku_cfg = fix->sku;
1709                 spec->cdefine.fixup = 1;
1710         }
1711         if (pre_init && cfg) {
1712 #ifdef CONFIG_SND_DEBUG_VERBOSE
1713                 snd_printdd(KERN_INFO "hda_codec: %s: Apply pincfg for %s\n",
1714                             codec->chip_name, modelname);
1715 #endif
1716                 for (; cfg->nid; cfg++)
1717                         snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1718         }
1719         if (!pre_init && fix->verbs) {
1720 #ifdef CONFIG_SND_DEBUG_VERBOSE
1721                 snd_printdd(KERN_INFO "hda_codec: %s: Apply fix-verbs for %s\n",
1722                             codec->chip_name, modelname);
1723 #endif
1724                 add_verb(codec->spec, fix->verbs);
1725         }
1726         if (fix->func) {
1727 #ifdef CONFIG_SND_DEBUG_VERBOSE
1728                 snd_printdd(KERN_INFO "hda_codec: %s: Apply fix-func for %s\n",
1729                             codec->chip_name, modelname);
1730 #endif
1731                 fix->func(codec, fix, pre_init);
1732         }
1733 }
1734
1735 static void alc_pick_fixup(struct hda_codec *codec,
1736                                  const struct snd_pci_quirk *quirk,
1737                                  const struct alc_fixup *fix,
1738                                  int pre_init)
1739 {
1740         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1741         if (quirk) {
1742                 fix += quirk->value;
1743 #ifdef CONFIG_SND_DEBUG_VERBOSE
1744                 __alc_pick_fixup(codec, fix, quirk->name, pre_init);
1745 #else
1746                 __alc_pick_fixup(codec, fix, NULL, pre_init);
1747 #endif
1748         }
1749 }
1750
1751 static void alc_pick_fixup_model(struct hda_codec *codec,
1752                                  const struct alc_model_fixup *models,
1753                                  const struct snd_pci_quirk *quirk,
1754                                  const struct alc_fixup *fix,
1755                                  int pre_init)
1756 {
1757         if (codec->modelname && models) {
1758                 while (models->name) {
1759                         if (!strcmp(codec->modelname, models->name)) {
1760                                 fix += models->id;
1761                                 break;
1762                         }
1763                         models++;
1764                 }
1765                 __alc_pick_fixup(codec, fix, codec->modelname, pre_init);
1766         } else {
1767                 alc_pick_fixup(codec, quirk, fix, pre_init);
1768         }
1769 }
1770
1771 static int alc_read_coef_idx(struct hda_codec *codec,
1772                         unsigned int coef_idx)
1773 {
1774         unsigned int val;
1775         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1776                                 coef_idx);
1777         val = snd_hda_codec_read(codec, 0x20, 0,
1778                                 AC_VERB_GET_PROC_COEF, 0);
1779         return val;
1780 }
1781
1782 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1783                                                         unsigned int coef_val)
1784 {
1785         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1786                             coef_idx);
1787         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1788                             coef_val);
1789 }
1790
1791 /* set right pin controls for digital I/O */
1792 static void alc_auto_init_digital(struct hda_codec *codec)
1793 {
1794         struct alc_spec *spec = codec->spec;
1795         int i;
1796         hda_nid_t pin;
1797
1798         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1799                 pin = spec->autocfg.dig_out_pins[i];
1800                 if (pin) {
1801                         snd_hda_codec_write(codec, pin, 0,
1802                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1803                                             PIN_OUT);
1804                 }
1805         }
1806         pin = spec->autocfg.dig_in_pin;
1807         if (pin)
1808                 snd_hda_codec_write(codec, pin, 0,
1809                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1810                                     PIN_IN);
1811 }
1812
1813 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1814 static void alc_auto_parse_digital(struct hda_codec *codec)
1815 {
1816         struct alc_spec *spec = codec->spec;
1817         int i, err;
1818         hda_nid_t dig_nid;
1819
1820         /* support multiple SPDIFs; the secondary is set up as a slave */
1821         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1822                 err = snd_hda_get_connections(codec,
1823                                               spec->autocfg.dig_out_pins[i],
1824                                               &dig_nid, 1);
1825                 if (err < 0)
1826                         continue;
1827                 if (!i) {
1828                         spec->multiout.dig_out_nid = dig_nid;
1829                         spec->dig_out_type = spec->autocfg.dig_out_type[0];
1830                 } else {
1831                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1832                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1833                                 break;
1834                         spec->slave_dig_outs[i - 1] = dig_nid;
1835                 }
1836         }
1837
1838         if (spec->autocfg.dig_in_pin) {
1839                 dig_nid = codec->start_nid;
1840                 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1841                         unsigned int wcaps = get_wcaps(codec, dig_nid);
1842                         if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1843                                 continue;
1844                         if (!(wcaps & AC_WCAP_DIGITAL))
1845                                 continue;
1846                         if (!(wcaps & AC_WCAP_CONN_LIST))
1847                                 continue;
1848                         err = get_connection_index(codec, dig_nid,
1849                                                    spec->autocfg.dig_in_pin);
1850                         if (err >= 0) {
1851                                 spec->dig_in_nid = dig_nid;
1852                                 break;
1853                         }
1854                 }
1855         }
1856 }
1857
1858 /*
1859  * ALC888
1860  */
1861
1862 /*
1863  * 2ch mode
1864  */
1865 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1866 /* Mic-in jack as mic in */
1867         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1868         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1869 /* Line-in jack as Line in */
1870         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1871         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1872 /* Line-Out as Front */
1873         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1874         { } /* end */
1875 };
1876
1877 /*
1878  * 4ch mode
1879  */
1880 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1881 /* Mic-in jack as mic in */
1882         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1883         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1884 /* Line-in jack as Surround */
1885         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1886         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1887 /* Line-Out as Front */
1888         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1889         { } /* end */
1890 };
1891
1892 /*
1893  * 6ch mode
1894  */
1895 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1896 /* Mic-in jack as CLFE */
1897         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1898         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1899 /* Line-in jack as Surround */
1900         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1901         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1902 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1903         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1904         { } /* end */
1905 };
1906
1907 /*
1908  * 8ch mode
1909  */
1910 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1911 /* Mic-in jack as CLFE */
1912         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1913         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1914 /* Line-in jack as Surround */
1915         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1916         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1917 /* Line-Out as Side */
1918         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1919         { } /* end */
1920 };
1921
1922 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1923         { 2, alc888_4ST_ch2_intel_init },
1924         { 4, alc888_4ST_ch4_intel_init },
1925         { 6, alc888_4ST_ch6_intel_init },
1926         { 8, alc888_4ST_ch8_intel_init },
1927 };
1928
1929 /*
1930  * ALC888 Fujitsu Siemens Amillo xa3530
1931  */
1932
1933 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1934 /* Front Mic: set to PIN_IN (empty by default) */
1935         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1936 /* Connect Internal HP to Front */
1937         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1938         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1939         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1940 /* Connect Bass HP to Front */
1941         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1942         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1943         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1944 /* Connect Line-Out side jack (SPDIF) to Side */
1945         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1946         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1947         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1948 /* Connect Mic jack to CLFE */
1949         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1950         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1951         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1952 /* Connect Line-in jack to Surround */
1953         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1954         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1955         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1956 /* Connect HP out jack to Front */
1957         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1958         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1959         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1960 /* Enable unsolicited event for HP jack and Line-out jack */
1961         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1962         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1963         {}
1964 };
1965
1966 static void alc_automute_amp(struct hda_codec *codec)
1967 {
1968         alc_automute_speaker(codec, 0);
1969 }
1970
1971 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1972                                          unsigned int res)
1973 {
1974         if (codec->vendor_id == 0x10ec0880)
1975                 res >>= 28;
1976         else
1977                 res >>= 26;
1978         if (res == ALC880_HP_EVENT)
1979                 alc_automute_amp(codec);
1980 }
1981
1982 static void alc889_automute_setup(struct hda_codec *codec)
1983 {
1984         struct alc_spec *spec = codec->spec;
1985
1986         spec->autocfg.hp_pins[0] = 0x15;
1987         spec->autocfg.speaker_pins[0] = 0x14;
1988         spec->autocfg.speaker_pins[1] = 0x16;
1989         spec->autocfg.speaker_pins[2] = 0x17;
1990         spec->autocfg.speaker_pins[3] = 0x19;
1991         spec->autocfg.speaker_pins[4] = 0x1a;
1992 }
1993
1994 static void alc889_intel_init_hook(struct hda_codec *codec)
1995 {
1996         alc889_coef_init(codec);
1997         alc_automute_amp(codec);
1998 }
1999
2000 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
2001 {
2002         struct alc_spec *spec = codec->spec;
2003
2004         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
2005         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
2006         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
2007         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
2008 }
2009
2010 /*
2011  * ALC888 Acer Aspire 4930G model
2012  */
2013
2014 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
2015 /* Front Mic: set to PIN_IN (empty by default) */
2016         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2017 /* Unselect Front Mic by default in input mixer 3 */
2018         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2019 /* Enable unsolicited event for HP jack */
2020         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2021 /* Connect Internal HP to front */
2022         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2023         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2024         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2025 /* Connect HP out to front */
2026         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2027         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2028         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2029         { }
2030 };
2031
2032 /*
2033  * ALC888 Acer Aspire 6530G model
2034  */
2035
2036 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
2037 /* Route to built-in subwoofer as well as speakers */
2038         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2039         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2040         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2041         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2042 /* Bias voltage on for external mic port */
2043         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2044 /* Front Mic: set to PIN_IN (empty by default) */
2045         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2046 /* Unselect Front Mic by default in input mixer 3 */
2047         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2048 /* Enable unsolicited event for HP jack */
2049         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2050 /* Enable speaker output */
2051         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2052         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2053         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2054 /* Enable headphone output */
2055         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2056         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2057         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2058         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2059         { }
2060 };
2061
2062 /*
2063  *ALC888 Acer Aspire 7730G model
2064  */
2065
2066 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
2067 /* Bias voltage on for external mic port */
2068         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2069 /* Front Mic: set to PIN_IN (empty by default) */
2070         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2071 /* Unselect Front Mic by default in input mixer 3 */
2072         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2073 /* Enable unsolicited event for HP jack */
2074         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2075 /* Enable speaker output */
2076         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2077         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2078         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2079 /* Enable headphone output */
2080         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2081         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2082         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2083         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2084 /*Enable internal subwoofer */
2085         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2086         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2087         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
2088         {0x17, AC_VERB_SET_EAPD_BTLENABLE, 2},
2089         { }
2090 };
2091
2092 /*
2093  * ALC889 Acer Aspire 8930G model
2094  */
2095
2096 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
2097 /* Front Mic: set to PIN_IN (empty by default) */
2098         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2099 /* Unselect Front Mic by default in input mixer 3 */
2100         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2101 /* Enable unsolicited event for HP jack */
2102         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2103 /* Connect Internal Front to Front */
2104         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2105         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2106         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2107 /* Connect Internal Rear to Rear */
2108         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2109         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2110         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
2111 /* Connect Internal CLFE to CLFE */
2112         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2113         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2114         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
2115 /* Connect HP out to Front */
2116         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2117         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2118         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2119 /* Enable all DACs */
2120 /*  DAC DISABLE/MUTE 1? */
2121 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
2122         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
2123         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2124 /*  DAC DISABLE/MUTE 2? */
2125 /*  some bit here disables the other DACs. Init=0x4900 */
2126         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
2127         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2128 /* DMIC fix
2129  * This laptop has a stereo digital microphone. The mics are only 1cm apart
2130  * which makes the stereo useless. However, either the mic or the ALC889
2131  * makes the signal become a difference/sum signal instead of standard
2132  * stereo, which is annoying. So instead we flip this bit which makes the
2133  * codec replicate the sum signal to both channels, turning it into a
2134  * normal mono mic.
2135  */
2136 /*  DMIC_CONTROL? Init value = 0x0001 */
2137         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
2138         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
2139         { }
2140 };
2141
2142 static struct hda_input_mux alc888_2_capture_sources[2] = {
2143         /* Front mic only available on one ADC */
2144         {
2145                 .num_items = 4,
2146                 .items = {
2147                         { "Mic", 0x0 },
2148                         { "Line", 0x2 },
2149                         { "CD", 0x4 },
2150                         { "Front Mic", 0xb },
2151                 },
2152         },
2153         {
2154                 .num_items = 3,
2155                 .items = {
2156                         { "Mic", 0x0 },
2157                         { "Line", 0x2 },
2158                         { "CD", 0x4 },
2159                 },
2160         }
2161 };
2162
2163 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
2164         /* Interal mic only available on one ADC */
2165         {
2166                 .num_items = 5,
2167                 .items = {
2168                         { "Ext Mic", 0x0 },
2169                         { "Line In", 0x2 },
2170                         { "CD", 0x4 },
2171                         { "Input Mix", 0xa },
2172                         { "Int Mic", 0xb },
2173                 },
2174         },
2175         {
2176                 .num_items = 4,
2177                 .items = {
2178                         { "Ext Mic", 0x0 },
2179                         { "Line In", 0x2 },
2180                         { "CD", 0x4 },
2181                         { "Input Mix", 0xa },
2182                 },
2183         }
2184 };
2185
2186 static struct hda_input_mux alc889_capture_sources[3] = {
2187         /* Digital mic only available on first "ADC" */
2188         {
2189                 .num_items = 5,
2190                 .items = {
2191                         { "Mic", 0x0 },
2192                         { "Line", 0x2 },
2193                         { "CD", 0x4 },
2194                         { "Front Mic", 0xb },
2195                         { "Input Mix", 0xa },
2196                 },
2197         },
2198         {
2199                 .num_items = 4,
2200                 .items = {
2201                         { "Mic", 0x0 },
2202                         { "Line", 0x2 },
2203                         { "CD", 0x4 },
2204                         { "Input Mix", 0xa },
2205                 },
2206         },
2207         {
2208                 .num_items = 4,
2209                 .items = {
2210                         { "Mic", 0x0 },
2211                         { "Line", 0x2 },
2212                         { "CD", 0x4 },
2213                         { "Input Mix", 0xa },
2214                 },
2215         }
2216 };
2217
2218 static struct snd_kcontrol_new alc888_base_mixer[] = {
2219         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2220         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2221         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2222         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2223         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2224                 HDA_OUTPUT),
2225         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2226         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2227         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2228         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2229         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2230         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2231         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2232         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2233         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2234         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2235         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
2236         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2237         { } /* end */
2238 };
2239
2240 static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
2241         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2242         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2243         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2244         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2245         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2246                 HDA_OUTPUT),
2247         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2248         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2249         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2250         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2251         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2252         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2253         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
2254         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2255         { } /* end */
2256 };
2257
2258
2259 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
2260 {
2261         struct alc_spec *spec = codec->spec;
2262
2263         spec->autocfg.hp_pins[0] = 0x15;
2264         spec->autocfg.speaker_pins[0] = 0x14;
2265         spec->autocfg.speaker_pins[1] = 0x16;
2266         spec->autocfg.speaker_pins[2] = 0x17;
2267 }
2268
2269 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
2270 {
2271         struct alc_spec *spec = codec->spec;
2272
2273         spec->autocfg.hp_pins[0] = 0x15;
2274         spec->autocfg.speaker_pins[0] = 0x14;
2275         spec->autocfg.speaker_pins[1] = 0x16;
2276         spec->autocfg.speaker_pins[2] = 0x17;
2277 }
2278
2279 static void alc888_acer_aspire_7730g_setup(struct hda_codec *codec)
2280 {
2281         struct alc_spec *spec = codec->spec;
2282
2283         spec->autocfg.hp_pins[0] = 0x15;
2284         spec->autocfg.speaker_pins[0] = 0x14;
2285         spec->autocfg.speaker_pins[1] = 0x16;
2286         spec->autocfg.speaker_pins[2] = 0x17;
2287 }
2288
2289 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
2290 {
2291         struct alc_spec *spec = codec->spec;
2292
2293         spec->autocfg.hp_pins[0] = 0x15;
2294         spec->autocfg.speaker_pins[0] = 0x14;
2295         spec->autocfg.speaker_pins[1] = 0x16;
2296         spec->autocfg.speaker_pins[2] = 0x1b;
2297 }
2298
2299 /*
2300  * ALC880 3-stack model
2301  *
2302  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
2303  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
2304  *                 F-Mic = 0x1b, HP = 0x19
2305  */
2306
2307 static hda_nid_t alc880_dac_nids[4] = {
2308         /* front, rear, clfe, rear_surr */
2309         0x02, 0x05, 0x04, 0x03
2310 };
2311
2312 static hda_nid_t alc880_adc_nids[3] = {
2313         /* ADC0-2 */
2314         0x07, 0x08, 0x09,
2315 };
2316
2317 /* The datasheet says the node 0x07 is connected from inputs,
2318  * but it shows zero connection in the real implementation on some devices.
2319  * Note: this is a 915GAV bug, fixed on 915GLV
2320  */
2321 static hda_nid_t alc880_adc_nids_alt[2] = {
2322         /* ADC1-2 */
2323         0x08, 0x09,
2324 };
2325
2326 #define ALC880_DIGOUT_NID       0x06
2327 #define ALC880_DIGIN_NID        0x0a
2328
2329 static struct hda_input_mux alc880_capture_source = {
2330         .num_items = 4,
2331         .items = {
2332                 { "Mic", 0x0 },
2333                 { "Front Mic", 0x3 },
2334                 { "Line", 0x2 },
2335                 { "CD", 0x4 },
2336         },
2337 };
2338
2339 /* channel source setting (2/6 channel selection for 3-stack) */
2340 /* 2ch mode */
2341 static struct hda_verb alc880_threestack_ch2_init[] = {
2342         /* set line-in to input, mute it */
2343         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2344         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2345         /* set mic-in to input vref 80%, mute it */
2346         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2347         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2348         { } /* end */
2349 };
2350
2351 /* 6ch mode */
2352 static struct hda_verb alc880_threestack_ch6_init[] = {
2353         /* set line-in to output, unmute it */
2354         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2355         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2356         /* set mic-in to output, unmute it */
2357         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2358         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2359         { } /* end */
2360 };
2361
2362 static struct hda_channel_mode alc880_threestack_modes[2] = {
2363         { 2, alc880_threestack_ch2_init },
2364         { 6, alc880_threestack_ch6_init },
2365 };
2366
2367 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
2368         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2369         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2370         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2371         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2372         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2373         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2374         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2375         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2376         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2377         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2378         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2379         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2380         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2381         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2382         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
2383         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
2384         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
2385         {
2386                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2387                 .name = "Channel Mode",
2388                 .info = alc_ch_mode_info,
2389                 .get = alc_ch_mode_get,
2390                 .put = alc_ch_mode_put,
2391         },
2392         { } /* end */
2393 };
2394
2395 /* capture mixer elements */
2396 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
2397                             struct snd_ctl_elem_info *uinfo)
2398 {
2399         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2400         struct alc_spec *spec = codec->spec;
2401         int err;
2402
2403         mutex_lock(&codec->control_mutex);
2404         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2405                                                       HDA_INPUT);
2406         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
2407         mutex_unlock(&codec->control_mutex);
2408         return err;
2409 }
2410
2411 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2412                            unsigned int size, unsigned int __user *tlv)
2413 {
2414         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2415         struct alc_spec *spec = codec->spec;
2416         int err;
2417
2418         mutex_lock(&codec->control_mutex);
2419         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2420                                                       HDA_INPUT);
2421         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
2422         mutex_unlock(&codec->control_mutex);
2423         return err;
2424 }
2425
2426 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
2427                              struct snd_ctl_elem_value *ucontrol);
2428
2429 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
2430                                  struct snd_ctl_elem_value *ucontrol,
2431                                  getput_call_t func)
2432 {
2433         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2434         struct alc_spec *spec = codec->spec;
2435         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2436         int err;
2437
2438         mutex_lock(&codec->control_mutex);
2439         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
2440                                                       3, 0, HDA_INPUT);
2441         err = func(kcontrol, ucontrol);
2442         mutex_unlock(&codec->control_mutex);
2443         return err;
2444 }
2445
2446 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
2447                            struct snd_ctl_elem_value *ucontrol)
2448 {
2449         return alc_cap_getput_caller(kcontrol, ucontrol,
2450                                      snd_hda_mixer_amp_volume_get);
2451 }
2452
2453 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2454                            struct snd_ctl_elem_value *ucontrol)
2455 {
2456         return alc_cap_getput_caller(kcontrol, ucontrol,
2457                                      snd_hda_mixer_amp_volume_put);
2458 }
2459
2460 /* capture mixer elements */
2461 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2462
2463 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2464                           struct snd_ctl_elem_value *ucontrol)
2465 {
2466         return alc_cap_getput_caller(kcontrol, ucontrol,
2467                                      snd_hda_mixer_amp_switch_get);
2468 }
2469
2470 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2471                           struct snd_ctl_elem_value *ucontrol)
2472 {
2473         return alc_cap_getput_caller(kcontrol, ucontrol,
2474                                      snd_hda_mixer_amp_switch_put);
2475 }
2476
2477 #define _DEFINE_CAPMIX(num) \
2478         { \
2479                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2480                 .name = "Capture Switch", \
2481                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2482                 .count = num, \
2483                 .info = alc_cap_sw_info, \
2484                 .get = alc_cap_sw_get, \
2485                 .put = alc_cap_sw_put, \
2486         }, \
2487         { \
2488                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2489                 .name = "Capture Volume", \
2490                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2491                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2492                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2493                 .count = num, \
2494                 .info = alc_cap_vol_info, \
2495                 .get = alc_cap_vol_get, \
2496                 .put = alc_cap_vol_put, \
2497                 .tlv = { .c = alc_cap_vol_tlv }, \
2498         }
2499
2500 #define _DEFINE_CAPSRC(num) \
2501         { \
2502                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2503                 /* .name = "Capture Source", */ \
2504                 .name = "Input Source", \
2505                 .count = num, \
2506                 .info = alc_mux_enum_info, \
2507                 .get = alc_mux_enum_get, \
2508                 .put = alc_mux_enum_put, \
2509         }
2510
2511 #define DEFINE_CAPMIX(num) \
2512 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2513         _DEFINE_CAPMIX(num),                                  \
2514         _DEFINE_CAPSRC(num),                                  \
2515         { } /* end */                                         \
2516 }
2517
2518 #define DEFINE_CAPMIX_NOSRC(num) \
2519 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2520         _DEFINE_CAPMIX(num),                                        \
2521         { } /* end */                                               \
2522 }
2523
2524 /* up to three ADCs */
2525 DEFINE_CAPMIX(1);
2526 DEFINE_CAPMIX(2);
2527 DEFINE_CAPMIX(3);
2528 DEFINE_CAPMIX_NOSRC(1);
2529 DEFINE_CAPMIX_NOSRC(2);
2530 DEFINE_CAPMIX_NOSRC(3);
2531
2532 /*
2533  * ALC880 5-stack model
2534  *
2535  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2536  *      Side = 0x02 (0xd)
2537  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2538  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2539  */
2540
2541 /* additional mixers to alc880_three_stack_mixer */
2542 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2543         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2544         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2545         { } /* end */
2546 };
2547
2548 /* channel source setting (6/8 channel selection for 5-stack) */
2549 /* 6ch mode */
2550 static struct hda_verb alc880_fivestack_ch6_init[] = {
2551         /* set line-in to input, mute it */
2552         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2553         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2554         { } /* end */
2555 };
2556
2557 /* 8ch mode */
2558 static struct hda_verb alc880_fivestack_ch8_init[] = {
2559         /* set line-in to output, unmute it */
2560         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2561         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2562         { } /* end */
2563 };
2564
2565 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2566         { 6, alc880_fivestack_ch6_init },
2567         { 8, alc880_fivestack_ch8_init },
2568 };
2569
2570
2571 /*
2572  * ALC880 6-stack model
2573  *
2574  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2575  *      Side = 0x05 (0x0f)
2576  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2577  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2578  */
2579
2580 static hda_nid_t alc880_6st_dac_nids[4] = {
2581         /* front, rear, clfe, rear_surr */
2582         0x02, 0x03, 0x04, 0x05
2583 };
2584
2585 static struct hda_input_mux alc880_6stack_capture_source = {
2586         .num_items = 4,
2587         .items = {
2588                 { "Mic", 0x0 },
2589                 { "Front Mic", 0x1 },
2590                 { "Line", 0x2 },
2591                 { "CD", 0x4 },
2592         },
2593 };
2594
2595 /* fixed 8-channels */
2596 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2597         { 8, NULL },
2598 };
2599
2600 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2601         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2602         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2603         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2604         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2605         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2606         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2607         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2608         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2609         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2610         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2611         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2612         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2613         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2614         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2615         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2616         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2617         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2618         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2619         {
2620                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2621                 .name = "Channel Mode",
2622                 .info = alc_ch_mode_info,
2623                 .get = alc_ch_mode_get,
2624                 .put = alc_ch_mode_put,
2625         },
2626         { } /* end */
2627 };
2628
2629
2630 /*
2631  * ALC880 W810 model
2632  *
2633  * W810 has rear IO for:
2634  * Front (DAC 02)
2635  * Surround (DAC 03)
2636  * Center/LFE (DAC 04)
2637  * Digital out (06)
2638  *
2639  * The system also has a pair of internal speakers, and a headphone jack.
2640  * These are both connected to Line2 on the codec, hence to DAC 02.
2641  *
2642  * There is a variable resistor to control the speaker or headphone
2643  * volume. This is a hardware-only device without a software API.
2644  *
2645  * Plugging headphones in will disable the internal speakers. This is
2646  * implemented in hardware, not via the driver using jack sense. In
2647  * a similar fashion, plugging into the rear socket marked "front" will
2648  * disable both the speakers and headphones.
2649  *
2650  * For input, there's a microphone jack, and an "audio in" jack.
2651  * These may not do anything useful with this driver yet, because I
2652  * haven't setup any initialization verbs for these yet...
2653  */
2654
2655 static hda_nid_t alc880_w810_dac_nids[3] = {
2656         /* front, rear/surround, clfe */
2657         0x02, 0x03, 0x04
2658 };
2659
2660 /* fixed 6 channels */
2661 static struct hda_channel_mode alc880_w810_modes[1] = {
2662         { 6, NULL }
2663 };
2664
2665 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2666 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2667         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2668         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2669         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2670         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2671         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2672         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2673         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2674         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2675         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2676         { } /* end */
2677 };
2678
2679
2680 /*
2681  * Z710V model
2682  *
2683  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2684  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2685  *                 Line = 0x1a
2686  */
2687
2688 static hda_nid_t alc880_z71v_dac_nids[1] = {
2689         0x02
2690 };
2691 #define ALC880_Z71V_HP_DAC      0x03
2692
2693 /* fixed 2 channels */
2694 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2695         { 2, NULL }
2696 };
2697
2698 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2699         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2700         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2701         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2702         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2703         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2704         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2705         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2706         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2707         { } /* end */
2708 };
2709
2710
2711 /*
2712  * ALC880 F1734 model
2713  *
2714  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2715  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2716  */
2717
2718 static hda_nid_t alc880_f1734_dac_nids[1] = {
2719         0x03
2720 };
2721 #define ALC880_F1734_HP_DAC     0x02
2722
2723 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2724         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2725         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2726         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2727         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2728         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2729         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2730         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2731         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2732         { } /* end */
2733 };
2734
2735 static struct hda_input_mux alc880_f1734_capture_source = {
2736         .num_items = 2,
2737         .items = {
2738                 { "Mic", 0x1 },
2739                 { "CD", 0x4 },
2740         },
2741 };
2742
2743
2744 /*
2745  * ALC880 ASUS model
2746  *
2747  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2748  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2749  *  Mic = 0x18, Line = 0x1a
2750  */
2751
2752 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2753 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2754
2755 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2756         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2757         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2758         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2759         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2760         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2761         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2762         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2763         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2764         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2765         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2766         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2767         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2768         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2769         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2770         {
2771                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2772                 .name = "Channel Mode",
2773                 .info = alc_ch_mode_info,
2774                 .get = alc_ch_mode_get,
2775                 .put = alc_ch_mode_put,
2776         },
2777         { } /* end */
2778 };
2779
2780 /*
2781  * ALC880 ASUS W1V model
2782  *
2783  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2784  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2785  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2786  */
2787
2788 /* additional mixers to alc880_asus_mixer */
2789 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2790         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2791         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2792         { } /* end */
2793 };
2794
2795 /* TCL S700 */
2796 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2797         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2798         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2799         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2800         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2801         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2802         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2803         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2804         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2805         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2806         { } /* end */
2807 };
2808
2809 /* Uniwill */
2810 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2811         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2812         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2813         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2814         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2815         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2816         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2817         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2818         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2819         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2820         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2821         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2822         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2823         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2824         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2825         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2826         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2827         {
2828                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2829                 .name = "Channel Mode",
2830                 .info = alc_ch_mode_info,
2831                 .get = alc_ch_mode_get,
2832                 .put = alc_ch_mode_put,
2833         },
2834         { } /* end */
2835 };
2836
2837 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2838         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2839         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2840         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2841         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2842         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2843         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2844         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2845         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2846         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2847         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2848         { } /* end */
2849 };
2850
2851 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2852         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2853         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2854         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2855         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2856         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2857         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2858         { } /* end */
2859 };
2860
2861 /*
2862  * virtual master controls
2863  */
2864
2865 /*
2866  * slave controls for virtual master
2867  */
2868 static const char *alc_slave_vols[] = {
2869         "Front Playback Volume",
2870         "Surround Playback Volume",
2871         "Center Playback Volume",
2872         "LFE Playback Volume",
2873         "Side Playback Volume",
2874         "Headphone Playback Volume",
2875         "Speaker Playback Volume",
2876         "Mono Playback Volume",
2877         "Line-Out Playback Volume",
2878         "PCM Playback Volume",
2879         NULL,
2880 };
2881
2882 static const char *alc_slave_sws[] = {
2883         "Front Playback Switch",
2884         "Surround Playback Switch",
2885         "Center Playback Switch",
2886         "LFE Playback Switch",
2887         "Side Playback Switch",
2888         "Headphone Playback Switch",
2889         "Speaker Playback Switch",
2890         "Mono Playback Switch",
2891         "IEC958 Playback Switch",
2892         "Line-Out Playback Switch",
2893         "PCM Playback Switch",
2894         NULL,
2895 };
2896
2897 /*
2898  * build control elements
2899  */
2900
2901 #define NID_MAPPING             (-1)
2902
2903 #define SUBDEV_SPEAKER_         (0 << 6)
2904 #define SUBDEV_HP_              (1 << 6)
2905 #define SUBDEV_LINE_            (2 << 6)
2906 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
2907 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
2908 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
2909
2910 static void alc_free_kctls(struct hda_codec *codec);
2911
2912 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2913 /* additional beep mixers; the actual parameters are overwritten at build */
2914 static struct snd_kcontrol_new alc_beep_mixer[] = {
2915         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2916         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2917         { } /* end */
2918 };
2919 #endif
2920
2921 static int alc_build_controls(struct hda_codec *codec)
2922 {
2923         struct alc_spec *spec = codec->spec;
2924         struct snd_kcontrol *kctl = NULL;
2925         struct snd_kcontrol_new *knew;
2926         int i, j, err;
2927         unsigned int u;
2928         hda_nid_t nid;
2929
2930         for (i = 0; i < spec->num_mixers; i++) {
2931                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2932                 if (err < 0)
2933                         return err;
2934         }
2935         if (spec->cap_mixer) {
2936                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2937                 if (err < 0)
2938                         return err;
2939         }
2940         if (spec->multiout.dig_out_nid) {
2941                 err = snd_hda_create_spdif_out_ctls(codec,
2942                                                     spec->multiout.dig_out_nid);
2943                 if (err < 0)
2944                         return err;
2945                 if (!spec->no_analog) {
2946                         err = snd_hda_create_spdif_share_sw(codec,
2947                                                             &spec->multiout);
2948                         if (err < 0)
2949                                 return err;
2950                         spec->multiout.share_spdif = 1;
2951                 }
2952         }
2953         if (spec->dig_in_nid) {
2954                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2955                 if (err < 0)
2956                         return err;
2957         }
2958
2959 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2960         /* create beep controls if needed */
2961         if (spec->beep_amp) {
2962                 struct snd_kcontrol_new *knew;
2963                 for (knew = alc_beep_mixer; knew->name; knew++) {
2964                         struct snd_kcontrol *kctl;
2965                         kctl = snd_ctl_new1(knew, codec);
2966                         if (!kctl)
2967                                 return -ENOMEM;
2968                         kctl->private_value = spec->beep_amp;
2969                         err = snd_hda_ctl_add(codec, 0, kctl);
2970                         if (err < 0)
2971                                 return err;
2972                 }
2973         }
2974 #endif
2975
2976         /* if we have no master control, let's create it */
2977         if (!spec->no_analog &&
2978             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2979                 unsigned int vmaster_tlv[4];
2980                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2981                                         HDA_OUTPUT, vmaster_tlv);
2982                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2983                                           vmaster_tlv, alc_slave_vols);
2984                 if (err < 0)
2985                         return err;
2986         }
2987         if (!spec->no_analog &&
2988             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2989                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2990                                           NULL, alc_slave_sws);
2991                 if (err < 0)
2992                         return err;
2993         }
2994
2995         /* assign Capture Source enums to NID */
2996         if (spec->capsrc_nids || spec->adc_nids) {
2997                 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
2998                 if (!kctl)
2999                         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
3000                 for (i = 0; kctl && i < kctl->count; i++) {
3001                         hda_nid_t *nids = spec->capsrc_nids;
3002                         if (!nids)
3003                                 nids = spec->adc_nids;
3004                         err = snd_hda_add_nid(codec, kctl, i, nids[i]);
3005                         if (err < 0)
3006                                 return err;
3007                 }
3008         }
3009         if (spec->cap_mixer) {
3010                 const char *kname = kctl ? kctl->id.name : NULL;
3011                 for (knew = spec->cap_mixer; knew->name; knew++) {
3012                         if (kname && strcmp(knew->name, kname) == 0)
3013                                 continue;
3014                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3015                         for (i = 0; kctl && i < kctl->count; i++) {
3016                                 err = snd_hda_add_nid(codec, kctl, i,
3017                                                       spec->adc_nids[i]);
3018                                 if (err < 0)
3019                                         return err;
3020                         }
3021                 }
3022         }
3023
3024         /* other nid->control mapping */
3025         for (i = 0; i < spec->num_mixers; i++) {
3026                 for (knew = spec->mixers[i]; knew->name; knew++) {
3027                         if (knew->iface != NID_MAPPING)
3028                                 continue;
3029                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3030                         if (kctl == NULL)
3031                                 continue;
3032                         u = knew->subdevice;
3033                         for (j = 0; j < 4; j++, u >>= 8) {
3034                                 nid = u & 0x3f;
3035                                 if (nid == 0)
3036                                         continue;
3037                                 switch (u & 0xc0) {
3038                                 case SUBDEV_SPEAKER_:
3039                                         nid = spec->autocfg.speaker_pins[nid];
3040                                         break;
3041                                 case SUBDEV_LINE_:
3042                                         nid = spec->autocfg.line_out_pins[nid];
3043                                         break;
3044                                 case SUBDEV_HP_:
3045                                         nid = spec->autocfg.hp_pins[nid];
3046                                         break;
3047                                 default:
3048                                         continue;
3049                                 }
3050                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
3051                                 if (err < 0)
3052                                         return err;
3053                         }
3054                         u = knew->private_value;
3055                         for (j = 0; j < 4; j++, u >>= 8) {
3056                                 nid = u & 0xff;
3057                                 if (nid == 0)
3058                                         continue;
3059                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
3060                                 if (err < 0)
3061                                         return err;
3062                         }
3063                 }
3064         }
3065
3066         alc_free_kctls(codec); /* no longer needed */
3067
3068         return 0;
3069 }
3070
3071
3072 /*
3073  * initialize the codec volumes, etc
3074  */
3075
3076 /*
3077  * generic initialization of ADC, input mixers and output mixers
3078  */
3079 static struct hda_verb alc880_volume_init_verbs[] = {
3080         /*
3081          * Unmute ADC0-2 and set the default input to mic-in
3082          */
3083         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3084         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3085         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3086         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3087         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3088         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3089
3090         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3091          * mixer widget
3092          * Note: PASD motherboards uses the Line In 2 as the input for front
3093          * panel mic (mic 2)
3094          */
3095         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
3096         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3097         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3098         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3099         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3100         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3101         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3102         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3103
3104         /*
3105          * Set up output mixers (0x0c - 0x0f)
3106          */
3107         /* set vol=0 to output mixers */
3108         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3109         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3110         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3111         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3112         /* set up input amps for analog loopback */
3113         /* Amp Indices: DAC = 0, mixer = 1 */
3114         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3115         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3116         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3117         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3118         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3119         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3120         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3121         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3122
3123         { }
3124 };
3125
3126 /*
3127  * 3-stack pin configuration:
3128  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
3129  */
3130 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
3131         /*
3132          * preset connection lists of input pins
3133          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3134          */
3135         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3136         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3137         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3138
3139         /*
3140          * Set pin mode and muting
3141          */
3142         /* set front pin widgets 0x14 for output */
3143         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3144         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3145         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3146         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3147         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3148         /* Mic2 (as headphone out) for HP output */
3149         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3150         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3151         /* Line In pin widget for input */
3152         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3153         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3154         /* Line2 (as front mic) pin widget for input and vref at 80% */
3155         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3156         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3157         /* CD pin widget for input */
3158         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3159
3160         { }
3161 };
3162
3163 /*
3164  * 5-stack pin configuration:
3165  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
3166  * line-in/side = 0x1a, f-mic = 0x1b
3167  */
3168 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
3169         /*
3170          * preset connection lists of input pins
3171          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3172          */
3173         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3174         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
3175
3176         /*
3177          * Set pin mode and muting
3178          */
3179         /* set pin widgets 0x14-0x17 for output */
3180         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3181         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3182         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3183         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3184         /* unmute pins for output (no gain on this amp) */
3185         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3186         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3187         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3188         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3189
3190         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3191         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3192         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3193         /* Mic2 (as headphone out) for HP output */
3194         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3195         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3196         /* Line In pin widget for input */
3197         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3198         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3199         /* Line2 (as front mic) pin widget for input and vref at 80% */
3200         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3201         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3202         /* CD pin widget for input */
3203         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3204
3205         { }
3206 };
3207
3208 /*
3209  * W810 pin configuration:
3210  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
3211  */
3212 static struct hda_verb alc880_pin_w810_init_verbs[] = {
3213         /* hphone/speaker input selector: front DAC */
3214         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
3215
3216         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3217         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3218         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3219         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3220         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3221         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3222
3223         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3224         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3225
3226         { }
3227 };
3228
3229 /*
3230  * Z71V pin configuration:
3231  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
3232  */
3233 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
3234         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3235         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3236         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3237         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3238
3239         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3240         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3241         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3242         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3243
3244         { }
3245 };
3246
3247 /*
3248  * 6-stack pin configuration:
3249  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
3250  * f-mic = 0x19, line = 0x1a, HP = 0x1b
3251  */
3252 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
3253         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3254
3255         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3256         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3257         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3258         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3259         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3260         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3261         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3262         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3263
3264         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3265         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3266         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3267         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3268         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3269         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3270         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3271         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3272         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3273
3274         { }
3275 };
3276
3277 /*
3278  * Uniwill pin configuration:
3279  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
3280  * line = 0x1a
3281  */
3282 static struct hda_verb alc880_uniwill_init_verbs[] = {
3283         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3284
3285         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3286         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3287         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3288         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3289         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3290         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3291         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3292         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3293         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3294         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3295         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3296         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3297         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3298         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3299
3300         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3301         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3302         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3303         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3304         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3305         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3306         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
3307         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
3308         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3309
3310         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3311         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
3312
3313         { }
3314 };
3315
3316 /*
3317 * Uniwill P53
3318 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
3319  */
3320 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
3321         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3322
3323         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3324         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3325         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3326         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3327         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3328         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3329         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3330         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3331         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3332         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3333         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3334         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3335
3336         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3337         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3338         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3339         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3340         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3341         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3342
3343         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3344         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
3345
3346         { }
3347 };
3348
3349 static struct hda_verb alc880_beep_init_verbs[] = {
3350         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
3351         { }
3352 };
3353
3354 /* auto-toggle front mic */
3355 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
3356 {
3357         unsigned int present;
3358         unsigned char bits;
3359
3360         present = snd_hda_jack_detect(codec, 0x18);
3361         bits = present ? HDA_AMP_MUTE : 0;
3362         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
3363 }
3364
3365 static void alc880_uniwill_setup(struct hda_codec *codec)
3366 {
3367         struct alc_spec *spec = codec->spec;
3368
3369         spec->autocfg.hp_pins[0] = 0x14;
3370         spec->autocfg.speaker_pins[0] = 0x15;
3371         spec->autocfg.speaker_pins[0] = 0x16;
3372 }
3373
3374 static void alc880_uniwill_init_hook(struct hda_codec *codec)
3375 {
3376         alc_automute_amp(codec);
3377         alc880_uniwill_mic_automute(codec);
3378 }
3379
3380 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
3381                                        unsigned int res)
3382 {
3383         /* Looks like the unsol event is incompatible with the standard
3384          * definition.  4bit tag is placed at 28 bit!
3385          */
3386         switch (res >> 28) {
3387         case ALC880_MIC_EVENT:
3388                 alc880_uniwill_mic_automute(codec);
3389                 break;
3390         default:
3391                 alc_automute_amp_unsol_event(codec, res);
3392                 break;
3393         }
3394 }
3395
3396 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
3397 {
3398         struct alc_spec *spec = codec->spec;
3399
3400         spec->autocfg.hp_pins[0] = 0x14;
3401         spec->autocfg.speaker_pins[0] = 0x15;
3402 }
3403
3404 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
3405 {
3406         unsigned int present;
3407
3408         present = snd_hda_codec_read(codec, 0x21, 0,
3409                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
3410         present &= HDA_AMP_VOLMASK;
3411         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
3412                                  HDA_AMP_VOLMASK, present);
3413         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
3414                                  HDA_AMP_VOLMASK, present);
3415 }
3416
3417 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
3418                                            unsigned int res)
3419 {
3420         /* Looks like the unsol event is incompatible with the standard
3421          * definition.  4bit tag is placed at 28 bit!
3422          */
3423         if ((res >> 28) == ALC880_DCVOL_EVENT)
3424                 alc880_uniwill_p53_dcvol_automute(codec);
3425         else
3426                 alc_automute_amp_unsol_event(codec, res);
3427 }
3428
3429 /*
3430  * F1734 pin configuration:
3431  * HP = 0x14, speaker-out = 0x15, mic = 0x18
3432  */
3433 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
3434         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
3435         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3436         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3437         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3438         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3439
3440         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3441         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3442         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3443         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3444
3445         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3446         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3447         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3448         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3449         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3450         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3451         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3452         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3453         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3454
3455         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3456         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3457
3458         { }
3459 };
3460
3461 /*
3462  * ASUS pin configuration:
3463  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3464  */
3465 static struct hda_verb alc880_pin_asus_init_verbs[] = {
3466         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3467         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3468         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3469         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3470
3471         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3472         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3473         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3474         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3475         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3476         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3477         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3478         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3479
3480         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3481         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3482         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3483         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3484         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3485         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3486         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3487         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3488         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3489
3490         { }
3491 };
3492
3493 /* Enable GPIO mask and set output */
3494 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
3495 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
3496 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
3497
3498 /* Clevo m520g init */
3499 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3500         /* headphone output */
3501         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3502         /* line-out */
3503         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3504         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3505         /* Line-in */
3506         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3507         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3508         /* CD */
3509         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3510         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3511         /* Mic1 (rear panel) */
3512         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3513         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3514         /* Mic2 (front panel) */
3515         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3516         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3517         /* headphone */
3518         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3519         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3520         /* change to EAPD mode */
3521         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3522         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3523
3524         { }
3525 };
3526
3527 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3528         /* change to EAPD mode */
3529         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3530         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3531
3532         /* Headphone output */
3533         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3534         /* Front output*/
3535         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3536         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3537
3538         /* Line In pin widget for input */
3539         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3540         /* CD pin widget for input */
3541         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3542         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3543         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3544
3545         /* change to EAPD mode */
3546         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3547         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3548
3549         { }
3550 };
3551
3552 /*
3553  * LG m1 express dual
3554  *
3555  * Pin assignment:
3556  *   Rear Line-In/Out (blue): 0x14
3557  *   Build-in Mic-In: 0x15
3558  *   Speaker-out: 0x17
3559  *   HP-Out (green): 0x1b
3560  *   Mic-In/Out (red): 0x19
3561  *   SPDIF-Out: 0x1e
3562  */
3563
3564 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3565 static hda_nid_t alc880_lg_dac_nids[3] = {
3566         0x05, 0x02, 0x03
3567 };
3568
3569 /* seems analog CD is not working */
3570 static struct hda_input_mux alc880_lg_capture_source = {
3571         .num_items = 3,
3572         .items = {
3573                 { "Mic", 0x1 },
3574                 { "Line", 0x5 },
3575                 { "Internal Mic", 0x6 },
3576         },
3577 };
3578
3579 /* 2,4,6 channel modes */
3580 static struct hda_verb alc880_lg_ch2_init[] = {
3581         /* set line-in and mic-in to input */
3582         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3583         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3584         { }
3585 };
3586
3587 static struct hda_verb alc880_lg_ch4_init[] = {
3588         /* set line-in to out and mic-in to input */
3589         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3590         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3591         { }
3592 };
3593
3594 static struct hda_verb alc880_lg_ch6_init[] = {
3595         /* set line-in and mic-in to output */
3596         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3597         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3598         { }
3599 };
3600
3601 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3602         { 2, alc880_lg_ch2_init },
3603         { 4, alc880_lg_ch4_init },
3604         { 6, alc880_lg_ch6_init },
3605 };
3606
3607 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3608         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3609         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3610         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3611         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3612         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3613         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3614         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3615         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3616         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3617         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3618         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3619         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3620         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3621         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3622         {
3623                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3624                 .name = "Channel Mode",
3625                 .info = alc_ch_mode_info,
3626                 .get = alc_ch_mode_get,
3627                 .put = alc_ch_mode_put,
3628         },
3629         { } /* end */
3630 };
3631
3632 static struct hda_verb alc880_lg_init_verbs[] = {
3633         /* set capture source to mic-in */
3634         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3635         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3636         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3637         /* mute all amp mixer inputs */
3638         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3639         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3640         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3641         /* line-in to input */
3642         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3643         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3644         /* built-in mic */
3645         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3646         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3647         /* speaker-out */
3648         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3649         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3650         /* mic-in to input */
3651         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3652         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3653         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3654         /* HP-out */
3655         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3656         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3657         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3658         /* jack sense */
3659         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3660         { }
3661 };
3662
3663 /* toggle speaker-output according to the hp-jack state */
3664 static void alc880_lg_setup(struct hda_codec *codec)
3665 {
3666         struct alc_spec *spec = codec->spec;
3667
3668         spec->autocfg.hp_pins[0] = 0x1b;
3669         spec->autocfg.speaker_pins[0] = 0x17;
3670 }
3671
3672 /*
3673  * LG LW20
3674  *
3675  * Pin assignment:
3676  *   Speaker-out: 0x14
3677  *   Mic-In: 0x18
3678  *   Built-in Mic-In: 0x19
3679  *   Line-In: 0x1b
3680  *   HP-Out: 0x1a
3681  *   SPDIF-Out: 0x1e
3682  */
3683
3684 static struct hda_input_mux alc880_lg_lw_capture_source = {
3685         .num_items = 3,
3686         .items = {
3687                 { "Mic", 0x0 },
3688                 { "Internal Mic", 0x1 },
3689                 { "Line In", 0x2 },
3690         },
3691 };
3692
3693 #define alc880_lg_lw_modes alc880_threestack_modes
3694
3695 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3696         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3697         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3698         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3699         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3700         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3701         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3702         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3703         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3704         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3705         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3706         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3707         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3708         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3709         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3710         {
3711                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3712                 .name = "Channel Mode",
3713                 .info = alc_ch_mode_info,
3714                 .get = alc_ch_mode_get,
3715                 .put = alc_ch_mode_put,
3716         },
3717         { } /* end */
3718 };
3719
3720 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3721         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3722         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3723         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3724
3725         /* set capture source to mic-in */
3726         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3727         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3728         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3729         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3730         /* speaker-out */
3731         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3732         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3733         /* HP-out */
3734         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3735         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3736         /* mic-in to input */
3737         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3738         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3739         /* built-in mic */
3740         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3741         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3742         /* jack sense */
3743         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3744         { }
3745 };
3746
3747 /* toggle speaker-output according to the hp-jack state */
3748 static void alc880_lg_lw_setup(struct hda_codec *codec)
3749 {
3750         struct alc_spec *spec = codec->spec;
3751
3752         spec->autocfg.hp_pins[0] = 0x1b;
3753         spec->autocfg.speaker_pins[0] = 0x14;
3754 }
3755
3756 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3757         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3758         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3759         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3760         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3761         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3762         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3763         { } /* end */
3764 };
3765
3766 static struct hda_input_mux alc880_medion_rim_capture_source = {
3767         .num_items = 2,
3768         .items = {
3769                 { "Mic", 0x0 },
3770                 { "Internal Mic", 0x1 },
3771         },
3772 };
3773
3774 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3775         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3776
3777         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3778         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3779
3780         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3781         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3782         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3783         /* Mic2 (as headphone out) for HP output */
3784         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3785         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3786         /* Internal Speaker */
3787         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3788         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3789
3790         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3791         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3792
3793         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3794         { }
3795 };
3796
3797 /* toggle speaker-output according to the hp-jack state */
3798 static void alc880_medion_rim_automute(struct hda_codec *codec)
3799 {
3800         struct alc_spec *spec = codec->spec;
3801         alc_automute_amp(codec);
3802         /* toggle EAPD */
3803         if (spec->jack_present)
3804                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3805         else
3806                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3807 }
3808
3809 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3810                                           unsigned int res)
3811 {
3812         /* Looks like the unsol event is incompatible with the standard
3813          * definition.  4bit tag is placed at 28 bit!
3814          */
3815         if ((res >> 28) == ALC880_HP_EVENT)
3816                 alc880_medion_rim_automute(codec);
3817 }
3818
3819 static void alc880_medion_rim_setup(struct hda_codec *codec)
3820 {
3821         struct alc_spec *spec = codec->spec;
3822
3823         spec->autocfg.hp_pins[0] = 0x14;
3824         spec->autocfg.speaker_pins[0] = 0x1b;
3825 }
3826
3827 #ifdef CONFIG_SND_HDA_POWER_SAVE
3828 static struct hda_amp_list alc880_loopbacks[] = {
3829         { 0x0b, HDA_INPUT, 0 },
3830         { 0x0b, HDA_INPUT, 1 },
3831         { 0x0b, HDA_INPUT, 2 },
3832         { 0x0b, HDA_INPUT, 3 },
3833         { 0x0b, HDA_INPUT, 4 },
3834         { } /* end */
3835 };
3836
3837 static struct hda_amp_list alc880_lg_loopbacks[] = {
3838         { 0x0b, HDA_INPUT, 1 },
3839         { 0x0b, HDA_INPUT, 6 },
3840         { 0x0b, HDA_INPUT, 7 },
3841         { } /* end */
3842 };
3843 #endif
3844
3845 /*
3846  * Common callbacks
3847  */
3848
3849 static int alc_init(struct hda_codec *codec)
3850 {
3851         struct alc_spec *spec = codec->spec;
3852         unsigned int i;
3853
3854         alc_fix_pll(codec);
3855         alc_auto_init_amp(codec, spec->init_amp);
3856
3857         for (i = 0; i < spec->num_init_verbs; i++)
3858                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3859
3860         if (spec->init_hook)
3861                 spec->init_hook(codec);
3862
3863         hda_call_check_power_status(codec, 0x01);
3864         return 0;
3865 }
3866
3867 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3868 {
3869         struct alc_spec *spec = codec->spec;
3870
3871         if (spec->unsol_event)
3872                 spec->unsol_event(codec, res);
3873 }
3874
3875 #ifdef CONFIG_SND_HDA_POWER_SAVE
3876 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3877 {
3878         struct alc_spec *spec = codec->spec;
3879         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3880 }
3881 #endif
3882
3883 /*
3884  * Analog playback callbacks
3885  */
3886 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3887                                     struct hda_codec *codec,
3888                                     struct snd_pcm_substream *substream)
3889 {
3890         struct alc_spec *spec = codec->spec;
3891         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3892                                              hinfo);
3893 }
3894
3895 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3896                                        struct hda_codec *codec,
3897                                        unsigned int stream_tag,
3898                                        unsigned int format,
3899                                        struct snd_pcm_substream *substream)
3900 {
3901         struct alc_spec *spec = codec->spec;
3902         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3903                                                 stream_tag, format, substream);
3904 }
3905
3906 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3907                                        struct hda_codec *codec,
3908                                        struct snd_pcm_substream *substream)
3909 {
3910         struct alc_spec *spec = codec->spec;
3911         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3912 }
3913
3914 /*
3915  * Digital out
3916  */
3917 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3918                                         struct hda_codec *codec,
3919                                         struct snd_pcm_substream *substream)
3920 {
3921         struct alc_spec *spec = codec->spec;
3922         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3923 }
3924
3925 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3926                                            struct hda_codec *codec,
3927                                            unsigned int stream_tag,
3928                                            unsigned int format,
3929                                            struct snd_pcm_substream *substream)
3930 {
3931         struct alc_spec *spec = codec->spec;
3932         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3933                                              stream_tag, format, substream);
3934 }
3935
3936 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3937                                            struct hda_codec *codec,
3938                                            struct snd_pcm_substream *substream)
3939 {
3940         struct alc_spec *spec = codec->spec;
3941         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3942 }
3943
3944 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3945                                          struct hda_codec *codec,
3946                                          struct snd_pcm_substream *substream)
3947 {
3948         struct alc_spec *spec = codec->spec;
3949         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3950 }
3951
3952 /*
3953  * Analog capture
3954  */
3955 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3956                                       struct hda_codec *codec,
3957                                       unsigned int stream_tag,
3958                                       unsigned int format,
3959                                       struct snd_pcm_substream *substream)
3960 {
3961         struct alc_spec *spec = codec->spec;
3962
3963         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3964                                    stream_tag, 0, format);
3965         return 0;
3966 }
3967
3968 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3969                                       struct hda_codec *codec,
3970                                       struct snd_pcm_substream *substream)
3971 {
3972         struct alc_spec *spec = codec->spec;
3973
3974         snd_hda_codec_cleanup_stream(codec,
3975                                      spec->adc_nids[substream->number + 1]);
3976         return 0;
3977 }
3978
3979 /* analog capture with dynamic dual-adc changes */
3980 static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3981                                        struct hda_codec *codec,
3982                                        unsigned int stream_tag,
3983                                        unsigned int format,
3984                                        struct snd_pcm_substream *substream)
3985 {
3986         struct alc_spec *spec = codec->spec;
3987         spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
3988         spec->cur_adc_stream_tag = stream_tag;
3989         spec->cur_adc_format = format;
3990         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
3991         return 0;
3992 }
3993
3994 static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3995                                        struct hda_codec *codec,
3996                                        struct snd_pcm_substream *substream)
3997 {
3998         struct alc_spec *spec = codec->spec;
3999         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
4000         spec->cur_adc = 0;
4001         return 0;
4002 }
4003
4004 static struct hda_pcm_stream dualmic_pcm_analog_capture = {
4005         .substreams = 1,
4006         .channels_min = 2,
4007         .channels_max = 2,
4008         .nid = 0, /* fill later */
4009         .ops = {
4010                 .prepare = dualmic_capture_pcm_prepare,
4011                 .cleanup = dualmic_capture_pcm_cleanup
4012         },
4013 };
4014
4015 /*
4016  */
4017 static struct hda_pcm_stream alc880_pcm_analog_playback = {
4018         .substreams = 1,
4019         .channels_min = 2,
4020         .channels_max = 8,
4021         /* NID is set in alc_build_pcms */
4022         .ops = {
4023                 .open = alc880_playback_pcm_open,
4024                 .prepare = alc880_playback_pcm_prepare,
4025                 .cleanup = alc880_playback_pcm_cleanup
4026         },
4027 };
4028
4029 static struct hda_pcm_stream alc880_pcm_analog_capture = {
4030         .substreams = 1,
4031         .channels_min = 2,
4032         .channels_max = 2,
4033         /* NID is set in alc_build_pcms */
4034 };
4035
4036 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
4037         .substreams = 1,
4038         .channels_min = 2,
4039         .channels_max = 2,
4040         /* NID is set in alc_build_pcms */
4041 };
4042
4043 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
4044         .substreams = 2, /* can be overridden */
4045         .channels_min = 2,
4046         .channels_max = 2,
4047         /* NID is set in alc_build_pcms */
4048         .ops = {
4049                 .prepare = alc880_alt_capture_pcm_prepare,
4050                 .cleanup = alc880_alt_capture_pcm_cleanup
4051         },
4052 };
4053
4054 static struct hda_pcm_stream alc880_pcm_digital_playback = {
4055         .substreams = 1,
4056         .channels_min = 2,
4057         .channels_max = 2,
4058         /* NID is set in alc_build_pcms */
4059         .ops = {
4060                 .open = alc880_dig_playback_pcm_open,
4061                 .close = alc880_dig_playback_pcm_close,
4062                 .prepare = alc880_dig_playback_pcm_prepare,
4063                 .cleanup = alc880_dig_playback_pcm_cleanup
4064         },
4065 };
4066
4067 static struct hda_pcm_stream alc880_pcm_digital_capture = {
4068         .substreams = 1,
4069         .channels_min = 2,
4070         .channels_max = 2,
4071         /* NID is set in alc_build_pcms */
4072 };
4073
4074 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
4075 static struct hda_pcm_stream alc_pcm_null_stream = {
4076         .substreams = 0,
4077         .channels_min = 0,
4078         .channels_max = 0,
4079 };
4080
4081 static int alc_build_pcms(struct hda_codec *codec)
4082 {
4083         struct alc_spec *spec = codec->spec;
4084         struct hda_pcm *info = spec->pcm_rec;
4085         int i;
4086
4087         codec->num_pcms = 1;
4088         codec->pcm_info = info;
4089
4090         if (spec->no_analog)
4091                 goto skip_analog;
4092
4093         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
4094                  "%s Analog", codec->chip_name);
4095         info->name = spec->stream_name_analog;
4096
4097         if (spec->stream_analog_playback) {
4098                 if (snd_BUG_ON(!spec->multiout.dac_nids))
4099                         return -EINVAL;
4100                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
4101                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4102         }
4103         if (spec->stream_analog_capture) {
4104                 if (snd_BUG_ON(!spec->adc_nids))
4105                         return -EINVAL;
4106                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
4107                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4108         }
4109
4110         if (spec->channel_mode) {
4111                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
4112                 for (i = 0; i < spec->num_channel_mode; i++) {
4113                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
4114                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
4115                         }
4116                 }
4117         }
4118
4119  skip_analog:
4120         /* SPDIF for stream index #1 */
4121         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4122                 snprintf(spec->stream_name_digital,
4123                          sizeof(spec->stream_name_digital),
4124                          "%s Digital", codec->chip_name);
4125                 codec->num_pcms = 2;
4126                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4127                 info = spec->pcm_rec + 1;
4128                 info->name = spec->stream_name_digital;
4129                 if (spec->dig_out_type)
4130                         info->pcm_type = spec->dig_out_type;
4131                 else
4132                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
4133                 if (spec->multiout.dig_out_nid &&
4134                     spec->stream_digital_playback) {
4135                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
4136                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4137                 }
4138                 if (spec->dig_in_nid &&
4139                     spec->stream_digital_capture) {
4140                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
4141                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4142                 }
4143                 /* FIXME: do we need this for all Realtek codec models? */
4144                 codec->spdif_status_reset = 1;
4145         }
4146
4147         if (spec->no_analog)
4148                 return 0;
4149
4150         /* If the use of more than one ADC is requested for the current
4151          * model, configure a second analog capture-only PCM.
4152          */
4153         /* Additional Analaog capture for index #2 */
4154         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
4155             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
4156                 codec->num_pcms = 3;
4157                 info = spec->pcm_rec + 2;
4158                 info->name = spec->stream_name_analog;
4159                 if (spec->alt_dac_nid) {
4160                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4161                                 *spec->stream_analog_alt_playback;
4162                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4163                                 spec->alt_dac_nid;
4164                 } else {
4165                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4166                                 alc_pcm_null_stream;
4167                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4168                 }
4169                 if (spec->num_adc_nids > 1) {
4170                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4171                                 *spec->stream_analog_alt_capture;
4172                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4173                                 spec->adc_nids[1];
4174                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4175                                 spec->num_adc_nids - 1;
4176                 } else {
4177                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4178                                 alc_pcm_null_stream;
4179                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4180                 }
4181         }
4182
4183         return 0;
4184 }
4185
4186 static inline void alc_shutup(struct hda_codec *codec)
4187 {
4188         snd_hda_shutup_pins(codec);
4189 }
4190
4191 static void alc_free_kctls(struct hda_codec *codec)
4192 {
4193         struct alc_spec *spec = codec->spec;
4194
4195         if (spec->kctls.list) {
4196                 struct snd_kcontrol_new *kctl = spec->kctls.list;
4197                 int i;
4198                 for (i = 0; i < spec->kctls.used; i++)
4199                         kfree(kctl[i].name);
4200         }
4201         snd_array_free(&spec->kctls);
4202 }
4203
4204 static void alc_free(struct hda_codec *codec)
4205 {
4206         struct alc_spec *spec = codec->spec;
4207
4208         if (!spec)
4209                 return;
4210
4211         alc_shutup(codec);
4212         alc_free_kctls(codec);
4213         kfree(spec);
4214         snd_hda_detach_beep_device(codec);
4215 }
4216
4217 #ifdef CONFIG_SND_HDA_POWER_SAVE
4218 static void alc_power_eapd(struct hda_codec *codec)
4219 {
4220         /* We currently only handle front, HP */
4221         switch (codec->vendor_id) {
4222         case 0x10ec0260:
4223                 set_eapd(codec, 0x0f, 0);
4224                 set_eapd(codec, 0x10, 0);
4225                 break;
4226         case 0x10ec0262:
4227         case 0x10ec0267:
4228         case 0x10ec0268:
4229         case 0x10ec0269:
4230         case 0x10ec0270:
4231         case 0x10ec0272:
4232         case 0x10ec0660:
4233         case 0x10ec0662:
4234         case 0x10ec0663:
4235         case 0x10ec0862:
4236         case 0x10ec0889:
4237                 set_eapd(codec, 0x14, 0);
4238                 set_eapd(codec, 0x15, 0);
4239                 break;
4240         }
4241 }
4242
4243 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
4244 {
4245         struct alc_spec *spec = codec->spec;
4246         alc_shutup(codec);
4247         if (spec && spec->power_hook)
4248                 spec->power_hook(codec);
4249         return 0;
4250 }
4251 #endif
4252
4253 #ifdef SND_HDA_NEEDS_RESUME
4254 static int alc_resume(struct hda_codec *codec)
4255 {
4256         codec->patch_ops.init(codec);
4257         snd_hda_codec_resume_amp(codec);
4258         snd_hda_codec_resume_cache(codec);
4259         hda_call_check_power_status(codec, 0x01);
4260         return 0;
4261 }
4262 #endif
4263
4264 /*
4265  */
4266 static struct hda_codec_ops alc_patch_ops = {
4267         .build_controls = alc_build_controls,
4268         .build_pcms = alc_build_pcms,
4269         .init = alc_init,
4270         .free = alc_free,
4271         .unsol_event = alc_unsol_event,
4272 #ifdef SND_HDA_NEEDS_RESUME
4273         .resume = alc_resume,
4274 #endif
4275 #ifdef CONFIG_SND_HDA_POWER_SAVE
4276         .suspend = alc_suspend,
4277         .check_power_status = alc_check_power_status,
4278 #endif
4279         .reboot_notify = alc_shutup,
4280 };
4281
4282 /* replace the codec chip_name with the given string */
4283 static int alc_codec_rename(struct hda_codec *codec, const char *name)
4284 {
4285         kfree(codec->chip_name);
4286         codec->chip_name = kstrdup(name, GFP_KERNEL);
4287         if (!codec->chip_name) {
4288                 alc_free(codec);
4289                 return -ENOMEM;
4290         }
4291         return 0;
4292 }
4293
4294 /*
4295  * Test configuration for debugging
4296  *
4297  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
4298  * enum controls.
4299  */
4300 #ifdef CONFIG_SND_DEBUG
4301 static hda_nid_t alc880_test_dac_nids[4] = {
4302         0x02, 0x03, 0x04, 0x05
4303 };
4304
4305 static struct hda_input_mux alc880_test_capture_source = {
4306         .num_items = 7,
4307         .items = {
4308                 { "In-1", 0x0 },
4309                 { "In-2", 0x1 },
4310                 { "In-3", 0x2 },
4311                 { "In-4", 0x3 },
4312                 { "CD", 0x4 },
4313                 { "Front", 0x5 },
4314                 { "Surround", 0x6 },
4315         },
4316 };
4317
4318 static struct hda_channel_mode alc880_test_modes[4] = {
4319         { 2, NULL },
4320         { 4, NULL },
4321         { 6, NULL },
4322         { 8, NULL },
4323 };
4324
4325 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
4326                                  struct snd_ctl_elem_info *uinfo)
4327 {
4328         static char *texts[] = {
4329                 "N/A", "Line Out", "HP Out",
4330                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
4331         };
4332         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4333         uinfo->count = 1;
4334         uinfo->value.enumerated.items = 8;
4335         if (uinfo->value.enumerated.item >= 8)
4336                 uinfo->value.enumerated.item = 7;
4337         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4338         return 0;
4339 }
4340
4341 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
4342                                 struct snd_ctl_elem_value *ucontrol)
4343 {
4344         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4345         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4346         unsigned int pin_ctl, item = 0;
4347
4348         pin_ctl = snd_hda_codec_read(codec, nid, 0,
4349                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4350         if (pin_ctl & AC_PINCTL_OUT_EN) {
4351                 if (pin_ctl & AC_PINCTL_HP_EN)
4352                         item = 2;
4353                 else
4354                         item = 1;
4355         } else if (pin_ctl & AC_PINCTL_IN_EN) {
4356                 switch (pin_ctl & AC_PINCTL_VREFEN) {
4357                 case AC_PINCTL_VREF_HIZ: item = 3; break;
4358                 case AC_PINCTL_VREF_50:  item = 4; break;
4359                 case AC_PINCTL_VREF_GRD: item = 5; break;
4360                 case AC_PINCTL_VREF_80:  item = 6; break;
4361                 case AC_PINCTL_VREF_100: item = 7; break;
4362                 }
4363         }
4364         ucontrol->value.enumerated.item[0] = item;
4365         return 0;
4366 }
4367
4368 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
4369                                 struct snd_ctl_elem_value *ucontrol)
4370 {
4371         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4372         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4373         static unsigned int ctls[] = {
4374                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
4375                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
4376                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
4377                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
4378                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
4379                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
4380         };
4381         unsigned int old_ctl, new_ctl;
4382
4383         old_ctl = snd_hda_codec_read(codec, nid, 0,
4384                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4385         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
4386         if (old_ctl != new_ctl) {
4387                 int val;
4388                 snd_hda_codec_write_cache(codec, nid, 0,
4389                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4390                                           new_ctl);
4391                 val = ucontrol->value.enumerated.item[0] >= 3 ?
4392                         HDA_AMP_MUTE : 0;
4393                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
4394                                          HDA_AMP_MUTE, val);
4395                 return 1;
4396         }
4397         return 0;
4398 }
4399
4400 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
4401                                  struct snd_ctl_elem_info *uinfo)
4402 {
4403         static char *texts[] = {
4404                 "Front", "Surround", "CLFE", "Side"
4405         };
4406         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4407         uinfo->count = 1;
4408         uinfo->value.enumerated.items = 4;
4409         if (uinfo->value.enumerated.item >= 4)
4410                 uinfo->value.enumerated.item = 3;
4411         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4412         return 0;
4413 }
4414
4415 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
4416                                 struct snd_ctl_elem_value *ucontrol)
4417 {
4418         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4419         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4420         unsigned int sel;
4421
4422         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
4423         ucontrol->value.enumerated.item[0] = sel & 3;
4424         return 0;
4425 }
4426
4427 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
4428                                 struct snd_ctl_elem_value *ucontrol)
4429 {
4430         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4431         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4432         unsigned int sel;
4433
4434         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
4435         if (ucontrol->value.enumerated.item[0] != sel) {
4436                 sel = ucontrol->value.enumerated.item[0] & 3;
4437                 snd_hda_codec_write_cache(codec, nid, 0,
4438                                           AC_VERB_SET_CONNECT_SEL, sel);
4439                 return 1;
4440         }
4441         return 0;
4442 }
4443
4444 #define PIN_CTL_TEST(xname,nid) {                       \
4445                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4446                         .name = xname,                 \
4447                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4448                         .info = alc_test_pin_ctl_info, \
4449                         .get = alc_test_pin_ctl_get,   \
4450                         .put = alc_test_pin_ctl_put,   \
4451                         .private_value = nid           \
4452                         }
4453
4454 #define PIN_SRC_TEST(xname,nid) {                       \
4455                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4456                         .name = xname,                 \
4457                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4458                         .info = alc_test_pin_src_info, \
4459                         .get = alc_test_pin_src_get,   \
4460                         .put = alc_test_pin_src_put,   \
4461                         .private_value = nid           \
4462                         }
4463
4464 static struct snd_kcontrol_new alc880_test_mixer[] = {
4465         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4466         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4467         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
4468         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4469         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4470         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4471         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
4472         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4473         PIN_CTL_TEST("Front Pin Mode", 0x14),
4474         PIN_CTL_TEST("Surround Pin Mode", 0x15),
4475         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
4476         PIN_CTL_TEST("Side Pin Mode", 0x17),
4477         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
4478         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
4479         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
4480         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
4481         PIN_SRC_TEST("In-1 Pin Source", 0x18),
4482         PIN_SRC_TEST("In-2 Pin Source", 0x19),
4483         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
4484         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
4485         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
4486         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
4487         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
4488         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
4489         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
4490         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
4491         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
4492         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
4493         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
4494         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
4495         {
4496                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4497                 .name = "Channel Mode",
4498                 .info = alc_ch_mode_info,
4499                 .get = alc_ch_mode_get,
4500                 .put = alc_ch_mode_put,
4501         },
4502         { } /* end */
4503 };
4504
4505 static struct hda_verb alc880_test_init_verbs[] = {
4506         /* Unmute inputs of 0x0c - 0x0f */
4507         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4508         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4509         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4510         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4511         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4512         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4513         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4514         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4515         /* Vol output for 0x0c-0x0f */
4516         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4517         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4518         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4519         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4520         /* Set output pins 0x14-0x17 */
4521         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4522         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4523         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4524         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4525         /* Unmute output pins 0x14-0x17 */
4526         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4527         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4528         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4529         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4530         /* Set input pins 0x18-0x1c */
4531         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4532         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4533         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4534         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4535         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4536         /* Mute input pins 0x18-0x1b */
4537         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4538         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4539         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4540         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4541         /* ADC set up */
4542         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4543         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4544         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4545         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4546         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4547         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4548         /* Analog input/passthru */
4549         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4550         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4551         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4552         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4553         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4554         { }
4555 };
4556 #endif
4557
4558 /*
4559  */
4560
4561 static const char *alc880_models[ALC880_MODEL_LAST] = {
4562         [ALC880_3ST]            = "3stack",
4563         [ALC880_TCL_S700]       = "tcl",
4564         [ALC880_3ST_DIG]        = "3stack-digout",
4565         [ALC880_CLEVO]          = "clevo",
4566         [ALC880_5ST]            = "5stack",
4567         [ALC880_5ST_DIG]        = "5stack-digout",
4568         [ALC880_W810]           = "w810",
4569         [ALC880_Z71V]           = "z71v",
4570         [ALC880_6ST]            = "6stack",
4571         [ALC880_6ST_DIG]        = "6stack-digout",
4572         [ALC880_ASUS]           = "asus",
4573         [ALC880_ASUS_W1V]       = "asus-w1v",
4574         [ALC880_ASUS_DIG]       = "asus-dig",
4575         [ALC880_ASUS_DIG2]      = "asus-dig2",
4576         [ALC880_UNIWILL_DIG]    = "uniwill",
4577         [ALC880_UNIWILL_P53]    = "uniwill-p53",
4578         [ALC880_FUJITSU]        = "fujitsu",
4579         [ALC880_F1734]          = "F1734",
4580         [ALC880_LG]             = "lg",
4581         [ALC880_LG_LW]          = "lg-lw",
4582         [ALC880_MEDION_RIM]     = "medion",
4583 #ifdef CONFIG_SND_DEBUG
4584         [ALC880_TEST]           = "test",
4585 #endif
4586         [ALC880_AUTO]           = "auto",
4587 };
4588
4589 static struct snd_pci_quirk alc880_cfg_tbl[] = {
4590         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4591         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4592         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4593         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4594         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4595         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4596         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4597         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4598         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4599         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4600         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4601         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4602         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4603         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4604         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4605         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4606         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4607         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4608         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4609         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4610         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4611         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4612         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4613         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4614         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4615         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4616         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4617         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4618         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4619         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4620         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4621         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4622         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4623         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4624         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4625         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4626         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4627         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4628         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4629         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4630         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4631         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4632         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4633         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4634         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4635         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4636         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4637         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4638         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4639         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
4640         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4641         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4642         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4643         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_LG),
4644         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4645         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4646         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4647         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4648         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4649         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4650         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4651         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4652         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4653         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4654         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4655         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4656         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4657         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4658         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4659         /* default Intel */
4660         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4661         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4662         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4663         {}
4664 };
4665
4666 /*
4667  * ALC880 codec presets
4668  */
4669 static struct alc_config_preset alc880_presets[] = {
4670         [ALC880_3ST] = {
4671                 .mixers = { alc880_three_stack_mixer },
4672                 .init_verbs = { alc880_volume_init_verbs,
4673                                 alc880_pin_3stack_init_verbs },
4674                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4675                 .dac_nids = alc880_dac_nids,
4676                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4677                 .channel_mode = alc880_threestack_modes,
4678                 .need_dac_fix = 1,
4679                 .input_mux = &alc880_capture_source,
4680         },
4681         [ALC880_3ST_DIG] = {
4682                 .mixers = { alc880_three_stack_mixer },
4683                 .init_verbs = { alc880_volume_init_verbs,
4684                                 alc880_pin_3stack_init_verbs },
4685                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4686                 .dac_nids = alc880_dac_nids,
4687                 .dig_out_nid = ALC880_DIGOUT_NID,
4688                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4689                 .channel_mode = alc880_threestack_modes,
4690                 .need_dac_fix = 1,
4691                 .input_mux = &alc880_capture_source,
4692         },
4693         [ALC880_TCL_S700] = {
4694                 .mixers = { alc880_tcl_s700_mixer },
4695                 .init_verbs = { alc880_volume_init_verbs,
4696                                 alc880_pin_tcl_S700_init_verbs,
4697                                 alc880_gpio2_init_verbs },
4698                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4699                 .dac_nids = alc880_dac_nids,
4700                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4701                 .num_adc_nids = 1, /* single ADC */
4702                 .hp_nid = 0x03,
4703                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4704                 .channel_mode = alc880_2_jack_modes,
4705                 .input_mux = &alc880_capture_source,
4706         },
4707         [ALC880_5ST] = {
4708                 .mixers = { alc880_three_stack_mixer,
4709                             alc880_five_stack_mixer},
4710                 .init_verbs = { alc880_volume_init_verbs,
4711                                 alc880_pin_5stack_init_verbs },
4712                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4713                 .dac_nids = alc880_dac_nids,
4714                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4715                 .channel_mode = alc880_fivestack_modes,
4716                 .input_mux = &alc880_capture_source,
4717         },
4718         [ALC880_5ST_DIG] = {
4719                 .mixers = { alc880_three_stack_mixer,
4720                             alc880_five_stack_mixer },
4721                 .init_verbs = { alc880_volume_init_verbs,
4722                                 alc880_pin_5stack_init_verbs },
4723                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4724                 .dac_nids = alc880_dac_nids,
4725                 .dig_out_nid = ALC880_DIGOUT_NID,
4726                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4727                 .channel_mode = alc880_fivestack_modes,
4728                 .input_mux = &alc880_capture_source,
4729         },
4730         [ALC880_6ST] = {
4731                 .mixers = { alc880_six_stack_mixer },
4732                 .init_verbs = { alc880_volume_init_verbs,
4733                                 alc880_pin_6stack_init_verbs },
4734                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4735                 .dac_nids = alc880_6st_dac_nids,
4736                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4737                 .channel_mode = alc880_sixstack_modes,
4738                 .input_mux = &alc880_6stack_capture_source,
4739         },
4740         [ALC880_6ST_DIG] = {
4741                 .mixers = { alc880_six_stack_mixer },
4742                 .init_verbs = { alc880_volume_init_verbs,
4743                                 alc880_pin_6stack_init_verbs },
4744                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4745                 .dac_nids = alc880_6st_dac_nids,
4746                 .dig_out_nid = ALC880_DIGOUT_NID,
4747                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4748                 .channel_mode = alc880_sixstack_modes,
4749                 .input_mux = &alc880_6stack_capture_source,
4750         },
4751         [ALC880_W810] = {
4752                 .mixers = { alc880_w810_base_mixer },
4753                 .init_verbs = { alc880_volume_init_verbs,
4754                                 alc880_pin_w810_init_verbs,
4755                                 alc880_gpio2_init_verbs },
4756                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4757                 .dac_nids = alc880_w810_dac_nids,
4758                 .dig_out_nid = ALC880_DIGOUT_NID,
4759                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4760                 .channel_mode = alc880_w810_modes,
4761                 .input_mux = &alc880_capture_source,
4762         },
4763         [ALC880_Z71V] = {
4764                 .mixers = { alc880_z71v_mixer },
4765                 .init_verbs = { alc880_volume_init_verbs,
4766                                 alc880_pin_z71v_init_verbs },
4767                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4768                 .dac_nids = alc880_z71v_dac_nids,
4769                 .dig_out_nid = ALC880_DIGOUT_NID,
4770                 .hp_nid = 0x03,
4771                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4772                 .channel_mode = alc880_2_jack_modes,
4773                 .input_mux = &alc880_capture_source,
4774         },
4775         [ALC880_F1734] = {
4776                 .mixers = { alc880_f1734_mixer },
4777                 .init_verbs = { alc880_volume_init_verbs,
4778                                 alc880_pin_f1734_init_verbs },
4779                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4780                 .dac_nids = alc880_f1734_dac_nids,
4781                 .hp_nid = 0x02,
4782                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4783                 .channel_mode = alc880_2_jack_modes,
4784                 .input_mux = &alc880_f1734_capture_source,
4785                 .unsol_event = alc880_uniwill_p53_unsol_event,
4786                 .setup = alc880_uniwill_p53_setup,
4787                 .init_hook = alc_automute_amp,
4788         },
4789         [ALC880_ASUS] = {
4790                 .mixers = { alc880_asus_mixer },
4791                 .init_verbs = { alc880_volume_init_verbs,
4792                                 alc880_pin_asus_init_verbs,
4793                                 alc880_gpio1_init_verbs },
4794                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4795                 .dac_nids = alc880_asus_dac_nids,
4796                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4797                 .channel_mode = alc880_asus_modes,
4798                 .need_dac_fix = 1,
4799                 .input_mux = &alc880_capture_source,
4800         },
4801         [ALC880_ASUS_DIG] = {
4802                 .mixers = { alc880_asus_mixer },
4803                 .init_verbs = { alc880_volume_init_verbs,
4804                                 alc880_pin_asus_init_verbs,
4805                                 alc880_gpio1_init_verbs },
4806                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4807                 .dac_nids = alc880_asus_dac_nids,
4808                 .dig_out_nid = ALC880_DIGOUT_NID,
4809                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4810                 .channel_mode = alc880_asus_modes,
4811                 .need_dac_fix = 1,
4812                 .input_mux = &alc880_capture_source,
4813         },
4814         [ALC880_ASUS_DIG2] = {
4815                 .mixers = { alc880_asus_mixer },
4816                 .init_verbs = { alc880_volume_init_verbs,
4817                                 alc880_pin_asus_init_verbs,
4818                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4819                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4820                 .dac_nids = alc880_asus_dac_nids,
4821                 .dig_out_nid = ALC880_DIGOUT_NID,
4822                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4823                 .channel_mode = alc880_asus_modes,
4824                 .need_dac_fix = 1,
4825                 .input_mux = &alc880_capture_source,
4826         },
4827         [ALC880_ASUS_W1V] = {
4828                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4829                 .init_verbs = { alc880_volume_init_verbs,
4830                                 alc880_pin_asus_init_verbs,
4831                                 alc880_gpio1_init_verbs },
4832                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4833                 .dac_nids = alc880_asus_dac_nids,
4834                 .dig_out_nid = ALC880_DIGOUT_NID,
4835                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4836                 .channel_mode = alc880_asus_modes,
4837                 .need_dac_fix = 1,
4838                 .input_mux = &alc880_capture_source,
4839         },
4840         [ALC880_UNIWILL_DIG] = {
4841                 .mixers = { alc880_asus_mixer },
4842                 .init_verbs = { alc880_volume_init_verbs,
4843                                 alc880_pin_asus_init_verbs },
4844                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4845                 .dac_nids = alc880_asus_dac_nids,
4846                 .dig_out_nid = ALC880_DIGOUT_NID,
4847                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4848                 .channel_mode = alc880_asus_modes,
4849                 .need_dac_fix = 1,
4850                 .input_mux = &alc880_capture_source,
4851         },
4852         [ALC880_UNIWILL] = {
4853                 .mixers = { alc880_uniwill_mixer },
4854                 .init_verbs = { alc880_volume_init_verbs,
4855                                 alc880_uniwill_init_verbs },
4856                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4857                 .dac_nids = alc880_asus_dac_nids,
4858                 .dig_out_nid = ALC880_DIGOUT_NID,
4859                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4860                 .channel_mode = alc880_threestack_modes,
4861                 .need_dac_fix = 1,
4862                 .input_mux = &alc880_capture_source,
4863                 .unsol_event = alc880_uniwill_unsol_event,
4864                 .setup = alc880_uniwill_setup,
4865                 .init_hook = alc880_uniwill_init_hook,
4866         },
4867         [ALC880_UNIWILL_P53] = {
4868                 .mixers = { alc880_uniwill_p53_mixer },
4869                 .init_verbs = { alc880_volume_init_verbs,
4870                                 alc880_uniwill_p53_init_verbs },
4871                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4872                 .dac_nids = alc880_asus_dac_nids,
4873                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4874                 .channel_mode = alc880_threestack_modes,
4875                 .input_mux = &alc880_capture_source,
4876                 .unsol_event = alc880_uniwill_p53_unsol_event,
4877                 .setup = alc880_uniwill_p53_setup,
4878                 .init_hook = alc_automute_amp,
4879         },
4880         [ALC880_FUJITSU] = {
4881                 .mixers = { alc880_fujitsu_mixer },
4882                 .init_verbs = { alc880_volume_init_verbs,
4883                                 alc880_uniwill_p53_init_verbs,
4884                                 alc880_beep_init_verbs },
4885                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4886                 .dac_nids = alc880_dac_nids,
4887                 .dig_out_nid = ALC880_DIGOUT_NID,
4888                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4889                 .channel_mode = alc880_2_jack_modes,
4890                 .input_mux = &alc880_capture_source,
4891                 .unsol_event = alc880_uniwill_p53_unsol_event,
4892                 .setup = alc880_uniwill_p53_setup,
4893                 .init_hook = alc_automute_amp,
4894         },
4895         [ALC880_CLEVO] = {
4896                 .mixers = { alc880_three_stack_mixer },
4897                 .init_verbs = { alc880_volume_init_verbs,
4898                                 alc880_pin_clevo_init_verbs },
4899                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4900                 .dac_nids = alc880_dac_nids,
4901                 .hp_nid = 0x03,
4902                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4903                 .channel_mode = alc880_threestack_modes,
4904                 .need_dac_fix = 1,
4905                 .input_mux = &alc880_capture_source,
4906         },
4907         [ALC880_LG] = {
4908                 .mixers = { alc880_lg_mixer },
4909                 .init_verbs = { alc880_volume_init_verbs,
4910                                 alc880_lg_init_verbs },
4911                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4912                 .dac_nids = alc880_lg_dac_nids,
4913                 .dig_out_nid = ALC880_DIGOUT_NID,
4914                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4915                 .channel_mode = alc880_lg_ch_modes,
4916                 .need_dac_fix = 1,
4917                 .input_mux = &alc880_lg_capture_source,
4918                 .unsol_event = alc_automute_amp_unsol_event,
4919                 .setup = alc880_lg_setup,
4920                 .init_hook = alc_automute_amp,
4921 #ifdef CONFIG_SND_HDA_POWER_SAVE
4922                 .loopbacks = alc880_lg_loopbacks,
4923 #endif
4924         },
4925         [ALC880_LG_LW] = {
4926                 .mixers = { alc880_lg_lw_mixer },
4927                 .init_verbs = { alc880_volume_init_verbs,
4928                                 alc880_lg_lw_init_verbs },
4929                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4930                 .dac_nids = alc880_dac_nids,
4931                 .dig_out_nid = ALC880_DIGOUT_NID,
4932                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4933                 .channel_mode = alc880_lg_lw_modes,
4934                 .input_mux = &alc880_lg_lw_capture_source,
4935                 .unsol_event = alc_automute_amp_unsol_event,
4936                 .setup = alc880_lg_lw_setup,
4937                 .init_hook = alc_automute_amp,
4938         },
4939         [ALC880_MEDION_RIM] = {
4940                 .mixers = { alc880_medion_rim_mixer },
4941                 .init_verbs = { alc880_volume_init_verbs,
4942                                 alc880_medion_rim_init_verbs,
4943                                 alc_gpio2_init_verbs },
4944                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4945                 .dac_nids = alc880_dac_nids,
4946                 .dig_out_nid = ALC880_DIGOUT_NID,
4947                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4948                 .channel_mode = alc880_2_jack_modes,
4949                 .input_mux = &alc880_medion_rim_capture_source,
4950                 .unsol_event = alc880_medion_rim_unsol_event,
4951                 .setup = alc880_medion_rim_setup,
4952                 .init_hook = alc880_medion_rim_automute,
4953         },
4954 #ifdef CONFIG_SND_DEBUG
4955         [ALC880_TEST] = {
4956                 .mixers = { alc880_test_mixer },
4957                 .init_verbs = { alc880_test_init_verbs },
4958                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4959                 .dac_nids = alc880_test_dac_nids,
4960                 .dig_out_nid = ALC880_DIGOUT_NID,
4961                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4962                 .channel_mode = alc880_test_modes,
4963                 .input_mux = &alc880_test_capture_source,
4964         },
4965 #endif
4966 };
4967
4968 /*
4969  * Automatic parse of I/O pins from the BIOS configuration
4970  */
4971
4972 enum {
4973         ALC_CTL_WIDGET_VOL,
4974         ALC_CTL_WIDGET_MUTE,
4975         ALC_CTL_BIND_MUTE,
4976 };
4977 static struct snd_kcontrol_new alc880_control_templates[] = {
4978         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4979         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4980         HDA_BIND_MUTE(NULL, 0, 0, 0),
4981 };
4982
4983 /* add dynamic controls */
4984 static int add_control(struct alc_spec *spec, int type, const char *name,
4985                        int cidx, unsigned long val)
4986 {
4987         struct snd_kcontrol_new *knew;
4988
4989         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4990         knew = snd_array_new(&spec->kctls);
4991         if (!knew)
4992                 return -ENOMEM;
4993         *knew = alc880_control_templates[type];
4994         knew->name = kstrdup(name, GFP_KERNEL);
4995         if (!knew->name)
4996                 return -ENOMEM;
4997         knew->index = cidx;
4998         if (get_amp_nid_(val))
4999                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
5000         knew->private_value = val;
5001         return 0;
5002 }
5003
5004 static int add_control_with_pfx(struct alc_spec *spec, int type,
5005                                 const char *pfx, const char *dir,
5006                                 const char *sfx, int cidx, unsigned long val)
5007 {
5008         char name[32];
5009         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
5010         return add_control(spec, type, name, cidx, val);
5011 }
5012
5013 #define add_pb_vol_ctrl(spec, type, pfx, val)                   \
5014         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
5015 #define add_pb_sw_ctrl(spec, type, pfx, val)                    \
5016         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
5017 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)                   \
5018         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
5019 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)                    \
5020         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
5021
5022 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
5023 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
5024 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
5025 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
5026 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
5027 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
5028 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
5029 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
5030 #define ALC880_PIN_CD_NID               0x1c
5031
5032 /* fill in the dac_nids table from the parsed pin configuration */
5033 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
5034                                      const struct auto_pin_cfg *cfg)
5035 {
5036         hda_nid_t nid;
5037         int assigned[4];
5038         int i, j;
5039
5040         memset(assigned, 0, sizeof(assigned));
5041         spec->multiout.dac_nids = spec->private_dac_nids;
5042
5043         /* check the pins hardwired to audio widget */
5044         for (i = 0; i < cfg->line_outs; i++) {
5045                 nid = cfg->line_out_pins[i];
5046                 if (alc880_is_fixed_pin(nid)) {
5047                         int idx = alc880_fixed_pin_idx(nid);
5048                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
5049                         assigned[idx] = 1;
5050                 }
5051         }
5052         /* left pins can be connect to any audio widget */
5053         for (i = 0; i < cfg->line_outs; i++) {
5054                 nid = cfg->line_out_pins[i];
5055                 if (alc880_is_fixed_pin(nid))
5056                         continue;
5057                 /* search for an empty channel */
5058                 for (j = 0; j < cfg->line_outs; j++) {
5059                         if (!assigned[j]) {
5060                                 spec->multiout.dac_nids[i] =
5061                                         alc880_idx_to_dac(j);
5062                                 assigned[j] = 1;
5063                                 break;
5064                         }
5065                 }
5066         }
5067         spec->multiout.num_dacs = cfg->line_outs;
5068         return 0;
5069 }
5070
5071 /* add playback controls from the parsed DAC table */
5072 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
5073                                              const struct auto_pin_cfg *cfg)
5074 {
5075         static const char *chname[4] = {
5076                 "Front", "Surround", NULL /*CLFE*/, "Side"
5077         };
5078         hda_nid_t nid;
5079         int i, err;
5080
5081         for (i = 0; i < cfg->line_outs; i++) {
5082                 if (!spec->multiout.dac_nids[i])
5083                         continue;
5084                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
5085                 if (i == 2) {
5086                         /* Center/LFE */
5087                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5088                                               "Center",
5089                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
5090                                                               HDA_OUTPUT));
5091                         if (err < 0)
5092                                 return err;
5093                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5094                                               "LFE",
5095                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
5096                                                               HDA_OUTPUT));
5097                         if (err < 0)
5098                                 return err;
5099                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5100                                              "Center",
5101                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
5102                                                               HDA_INPUT));
5103                         if (err < 0)
5104                                 return err;
5105                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5106                                              "LFE",
5107                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
5108                                                               HDA_INPUT));
5109                         if (err < 0)
5110                                 return err;
5111                 } else {
5112                         const char *pfx;
5113                         if (cfg->line_outs == 1 &&
5114                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
5115                                 pfx = "Speaker";
5116                         else
5117                                 pfx = chname[i];
5118                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5119                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
5120                                                               HDA_OUTPUT));
5121                         if (err < 0)
5122                                 return err;
5123                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5124                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
5125                                                               HDA_INPUT));
5126                         if (err < 0)
5127                                 return err;
5128                 }
5129         }
5130         return 0;
5131 }
5132
5133 /* add playback controls for speaker and HP outputs */
5134 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
5135                                         const char *pfx)
5136 {
5137         hda_nid_t nid;
5138         int err;
5139
5140         if (!pin)
5141                 return 0;
5142
5143         if (alc880_is_fixed_pin(pin)) {
5144                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
5145                 /* specify the DAC as the extra output */
5146                 if (!spec->multiout.hp_nid)
5147                         spec->multiout.hp_nid = nid;
5148                 else
5149                         spec->multiout.extra_out_nid[0] = nid;
5150                 /* control HP volume/switch on the output mixer amp */
5151                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
5152                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5153                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
5154                 if (err < 0)
5155                         return err;
5156                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5157                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
5158                 if (err < 0)
5159                         return err;
5160         } else if (alc880_is_multi_pin(pin)) {
5161                 /* set manual connection */
5162                 /* we have only a switch on HP-out PIN */
5163                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
5164                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
5165                 if (err < 0)
5166                         return err;
5167         }
5168         return 0;
5169 }
5170
5171 /* create input playback/capture controls for the given pin */
5172 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
5173                             const char *ctlname, int ctlidx,
5174                             int idx, hda_nid_t mix_nid)
5175 {
5176         int err;
5177
5178         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
5179                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5180         if (err < 0)
5181                 return err;
5182         err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
5183                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5184         if (err < 0)
5185                 return err;
5186         return 0;
5187 }
5188
5189 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
5190 {
5191         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
5192         return (pincap & AC_PINCAP_IN) != 0;
5193 }
5194
5195 /* create playback/capture controls for input pins */
5196 static int alc_auto_create_input_ctls(struct hda_codec *codec,
5197                                       const struct auto_pin_cfg *cfg,
5198                                       hda_nid_t mixer,
5199                                       hda_nid_t cap1, hda_nid_t cap2)
5200 {
5201         struct alc_spec *spec = codec->spec;
5202         struct hda_input_mux *imux = &spec->private_imux[0];
5203         int i, err, idx, type, type_idx = 0;
5204
5205         for (i = 0; i < cfg->num_inputs; i++) {
5206                 hda_nid_t pin;
5207                 const char *label;
5208
5209                 pin = cfg->inputs[i].pin;
5210                 if (!alc_is_input_pin(codec, pin))
5211                         continue;
5212
5213                 type = cfg->inputs[i].type;
5214                 if (i > 0 && type == cfg->inputs[i - 1].type)
5215                         type_idx++;
5216                 else
5217                         type_idx = 0;
5218                 label = hda_get_autocfg_input_label(codec, cfg, i);
5219                 if (mixer) {
5220                         idx = get_connection_index(codec, mixer, pin);
5221                         if (idx >= 0) {
5222                                 err = new_analog_input(spec, pin,
5223                                                        label, type_idx,
5224                                                        idx, mixer);
5225                                 if (err < 0)
5226                                         return err;
5227                         }
5228                 }
5229
5230                 if (!cap1)
5231                         continue;
5232                 idx = get_connection_index(codec, cap1, pin);
5233                 if (idx < 0 && cap2)
5234                         idx = get_connection_index(codec, cap2, pin);
5235                 if (idx >= 0)
5236                         snd_hda_add_imux_item(imux, label, idx, NULL);
5237         }
5238         return 0;
5239 }
5240
5241 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
5242                                                 const struct auto_pin_cfg *cfg)
5243 {
5244         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
5245 }
5246
5247 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
5248                                unsigned int pin_type)
5249 {
5250         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5251                             pin_type);
5252         /* unmute pin */
5253         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
5254                             AMP_OUT_UNMUTE);
5255 }
5256
5257 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
5258                                               hda_nid_t nid, int pin_type,
5259                                               int dac_idx)
5260 {
5261         alc_set_pin_output(codec, nid, pin_type);
5262         /* need the manual connection? */
5263         if (alc880_is_multi_pin(nid)) {
5264                 struct alc_spec *spec = codec->spec;
5265                 int idx = alc880_multi_pin_idx(nid);
5266                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
5267                                     AC_VERB_SET_CONNECT_SEL,
5268                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
5269         }
5270 }
5271
5272 static int get_pin_type(int line_out_type)
5273 {
5274         if (line_out_type == AUTO_PIN_HP_OUT)
5275                 return PIN_HP;
5276         else
5277                 return PIN_OUT;
5278 }
5279
5280 static void alc880_auto_init_multi_out(struct hda_codec *codec)
5281 {
5282         struct alc_spec *spec = codec->spec;
5283         int i;
5284
5285         for (i = 0; i < spec->autocfg.line_outs; i++) {
5286                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
5287                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5288                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
5289         }
5290 }
5291
5292 static void alc880_auto_init_extra_out(struct hda_codec *codec)
5293 {
5294         struct alc_spec *spec = codec->spec;
5295         hda_nid_t pin;
5296
5297         pin = spec->autocfg.speaker_pins[0];
5298         if (pin) /* connect to front */
5299                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
5300         pin = spec->autocfg.hp_pins[0];
5301         if (pin) /* connect to front */
5302                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
5303 }
5304
5305 static void alc880_auto_init_analog_input(struct hda_codec *codec)
5306 {
5307         struct alc_spec *spec = codec->spec;
5308         struct auto_pin_cfg *cfg = &spec->autocfg;
5309         int i;
5310
5311         for (i = 0; i < cfg->num_inputs; i++) {
5312                 hda_nid_t nid = cfg->inputs[i].pin;
5313                 if (alc_is_input_pin(codec, nid)) {
5314                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
5315                         if (nid != ALC880_PIN_CD_NID &&
5316                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5317                                 snd_hda_codec_write(codec, nid, 0,
5318                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5319                                                     AMP_OUT_MUTE);
5320                 }
5321         }
5322 }
5323
5324 static void alc880_auto_init_input_src(struct hda_codec *codec)
5325 {
5326         struct alc_spec *spec = codec->spec;
5327         int c;
5328
5329         for (c = 0; c < spec->num_adc_nids; c++) {
5330                 unsigned int mux_idx;
5331                 const struct hda_input_mux *imux;
5332                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
5333                 imux = &spec->input_mux[mux_idx];
5334                 if (!imux->num_items && mux_idx > 0)
5335                         imux = &spec->input_mux[0];
5336                 if (imux)
5337                         snd_hda_codec_write(codec, spec->adc_nids[c], 0,
5338                                             AC_VERB_SET_CONNECT_SEL,
5339                                             imux->items[0].index);
5340         }
5341 }
5342
5343 /* parse the BIOS configuration and set up the alc_spec */
5344 /* return 1 if successful, 0 if the proper config is not found,
5345  * or a negative error code
5346  */
5347 static int alc880_parse_auto_config(struct hda_codec *codec)
5348 {
5349         struct alc_spec *spec = codec->spec;
5350         int err;
5351         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
5352
5353         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5354                                            alc880_ignore);
5355         if (err < 0)
5356                 return err;
5357         if (!spec->autocfg.line_outs)
5358                 return 0; /* can't find valid BIOS pin config */
5359
5360         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
5361         if (err < 0)
5362                 return err;
5363         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
5364         if (err < 0)
5365                 return err;
5366         err = alc880_auto_create_extra_out(spec,
5367                                            spec->autocfg.speaker_pins[0],
5368                                            "Speaker");
5369         if (err < 0)
5370                 return err;
5371         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
5372                                            "Headphone");
5373         if (err < 0)
5374                 return err;
5375         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
5376         if (err < 0)
5377                 return err;
5378
5379         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5380
5381         alc_auto_parse_digital(codec);
5382
5383         if (spec->kctls.list)
5384                 add_mixer(spec, spec->kctls.list);
5385
5386         add_verb(spec, alc880_volume_init_verbs);
5387
5388         spec->num_mux_defs = 1;
5389         spec->input_mux = &spec->private_imux[0];
5390
5391         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
5392
5393         return 1;
5394 }
5395
5396 /* additional initialization for auto-configuration model */
5397 static void alc880_auto_init(struct hda_codec *codec)
5398 {
5399         struct alc_spec *spec = codec->spec;
5400         alc880_auto_init_multi_out(codec);
5401         alc880_auto_init_extra_out(codec);
5402         alc880_auto_init_analog_input(codec);
5403         alc880_auto_init_input_src(codec);
5404         alc_auto_init_digital(codec);
5405         if (spec->unsol_event)
5406                 alc_inithook(codec);
5407 }
5408
5409 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
5410  * one of two digital mic pins, e.g. on ALC272
5411  */
5412 static void fixup_automic_adc(struct hda_codec *codec)
5413 {
5414         struct alc_spec *spec = codec->spec;
5415         int i;
5416
5417         for (i = 0; i < spec->num_adc_nids; i++) {
5418                 hda_nid_t cap = spec->capsrc_nids ?
5419                         spec->capsrc_nids[i] : spec->adc_nids[i];
5420                 int iidx, eidx;
5421
5422                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
5423                 if (iidx < 0)
5424                         continue;
5425                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
5426                 if (eidx < 0)
5427                         continue;
5428                 spec->int_mic.mux_idx = iidx;
5429                 spec->ext_mic.mux_idx = eidx;
5430                 if (spec->capsrc_nids)
5431                         spec->capsrc_nids += i;
5432                 spec->adc_nids += i;
5433                 spec->num_adc_nids = 1;
5434                 return;
5435         }
5436         snd_printd(KERN_INFO "hda_codec: %s: "
5437                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
5438                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
5439         spec->auto_mic = 0; /* disable auto-mic to be sure */
5440 }
5441
5442 /* select or unmute the given capsrc route */
5443 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
5444                                     int idx)
5445 {
5446         if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
5447                 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
5448                                          HDA_AMP_MUTE, 0);
5449         } else {
5450                 snd_hda_codec_write_cache(codec, cap, 0,
5451                                           AC_VERB_SET_CONNECT_SEL, idx);
5452         }
5453 }
5454
5455 /* set the default connection to that pin */
5456 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
5457 {
5458         struct alc_spec *spec = codec->spec;
5459         int i;
5460
5461         for (i = 0; i < spec->num_adc_nids; i++) {
5462                 hda_nid_t cap = spec->capsrc_nids ?
5463                         spec->capsrc_nids[i] : spec->adc_nids[i];
5464                 int idx;
5465
5466                 idx = get_connection_index(codec, cap, pin);
5467                 if (idx < 0)
5468                         continue;
5469                 select_or_unmute_capsrc(codec, cap, idx);
5470                 return i; /* return the found index */
5471         }
5472         return -1; /* not found */
5473 }
5474
5475 /* choose the ADC/MUX containing the input pin and initialize the setup */
5476 static void fixup_single_adc(struct hda_codec *codec)
5477 {
5478         struct alc_spec *spec = codec->spec;
5479         struct auto_pin_cfg *cfg = &spec->autocfg;
5480         int i;
5481
5482         /* search for the input pin; there must be only one */
5483         if (cfg->num_inputs != 1)
5484                 return;
5485         i = init_capsrc_for_pin(codec, cfg->inputs[0].pin);
5486         if (i >= 0) {
5487                 /* use only this ADC */
5488                 if (spec->capsrc_nids)
5489                         spec->capsrc_nids += i;
5490                 spec->adc_nids += i;
5491                 spec->num_adc_nids = 1;
5492         }
5493 }
5494
5495 /* initialize dual adcs */
5496 static void fixup_dual_adc_switch(struct hda_codec *codec)
5497 {
5498         struct alc_spec *spec = codec->spec;
5499         init_capsrc_for_pin(codec, spec->ext_mic.pin);
5500         init_capsrc_for_pin(codec, spec->int_mic.pin);
5501 }
5502
5503 static void set_capture_mixer(struct hda_codec *codec)
5504 {
5505         struct alc_spec *spec = codec->spec;
5506         static struct snd_kcontrol_new *caps[2][3] = {
5507                 { alc_capture_mixer_nosrc1,
5508                   alc_capture_mixer_nosrc2,
5509                   alc_capture_mixer_nosrc3 },
5510                 { alc_capture_mixer1,
5511                   alc_capture_mixer2,
5512                   alc_capture_mixer3 },
5513         };
5514         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
5515                 int mux = 0;
5516                 int num_adcs = spec->num_adc_nids;
5517                 if (spec->dual_adc_switch)
5518                         fixup_dual_adc_switch(codec);
5519                 else if (spec->auto_mic)
5520                         fixup_automic_adc(codec);
5521                 else if (spec->input_mux) {
5522                         if (spec->input_mux->num_items > 1)
5523                                 mux = 1;
5524                         else if (spec->input_mux->num_items == 1)
5525                                 fixup_single_adc(codec);
5526                 }
5527                 if (spec->dual_adc_switch)
5528                         num_adcs = 1;
5529                 spec->cap_mixer = caps[mux][num_adcs - 1];
5530         }
5531 }
5532
5533 /* fill adc_nids (and capsrc_nids) containing all active input pins */
5534 static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
5535                                  int num_nids)
5536 {
5537         struct alc_spec *spec = codec->spec;
5538         struct auto_pin_cfg *cfg = &spec->autocfg;
5539         int n;
5540         hda_nid_t fallback_adc = 0, fallback_cap = 0;
5541
5542         for (n = 0; n < num_nids; n++) {
5543                 hda_nid_t adc, cap;
5544                 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5545                 int nconns, i, j;
5546
5547                 adc = nids[n];
5548                 if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5549                         continue;
5550                 cap = adc;
5551                 nconns = snd_hda_get_connections(codec, cap, conn,
5552                                                  ARRAY_SIZE(conn));
5553                 if (nconns == 1) {
5554                         cap = conn[0];
5555                         nconns = snd_hda_get_connections(codec, cap, conn,
5556                                                          ARRAY_SIZE(conn));
5557                 }
5558                 if (nconns <= 0)
5559                         continue;
5560                 if (!fallback_adc) {
5561                         fallback_adc = adc;
5562                         fallback_cap = cap;
5563                 }
5564                 for (i = 0; i < cfg->num_inputs; i++) {
5565                         hda_nid_t nid = cfg->inputs[i].pin;
5566                         for (j = 0; j < nconns; j++) {
5567                                 if (conn[j] == nid)
5568                                         break;
5569                         }
5570                         if (j >= nconns)
5571                                 break;
5572                 }
5573                 if (i >= cfg->num_inputs) {
5574                         int num_adcs = spec->num_adc_nids;
5575                         spec->private_adc_nids[num_adcs] = adc;
5576                         spec->private_capsrc_nids[num_adcs] = cap;
5577                         spec->num_adc_nids++;
5578                         spec->adc_nids = spec->private_adc_nids;
5579                         if (adc != cap)
5580                                 spec->capsrc_nids = spec->private_capsrc_nids;
5581                 }
5582         }
5583         if (!spec->num_adc_nids) {
5584                 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5585                        " using fallback 0x%x\n",
5586                        codec->chip_name, fallback_adc);
5587                 spec->private_adc_nids[0] = fallback_adc;
5588                 spec->adc_nids = spec->private_adc_nids;
5589                 if (fallback_adc != fallback_cap) {
5590                         spec->private_capsrc_nids[0] = fallback_cap;
5591                         spec->capsrc_nids = spec->private_adc_nids;
5592                 }
5593         }
5594 }
5595
5596 #ifdef CONFIG_SND_HDA_INPUT_BEEP
5597 #define set_beep_amp(spec, nid, idx, dir) \
5598         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5599
5600 static struct snd_pci_quirk beep_white_list[] = {
5601         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
5602         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
5603         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
5604         {}
5605 };
5606
5607 static inline int has_cdefine_beep(struct hda_codec *codec)
5608 {
5609         struct alc_spec *spec = codec->spec;
5610         const struct snd_pci_quirk *q;
5611         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
5612         if (q)
5613                 return q->value;
5614         return spec->cdefine.enable_pcbeep;
5615 }
5616 #else
5617 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
5618 #define has_cdefine_beep(codec)         0
5619 #endif
5620
5621 /*
5622  * OK, here we have finally the patch for ALC880
5623  */
5624
5625 static int patch_alc880(struct hda_codec *codec)
5626 {
5627         struct alc_spec *spec;
5628         int board_config;
5629         int err;
5630
5631         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5632         if (spec == NULL)
5633                 return -ENOMEM;
5634
5635         codec->spec = spec;
5636
5637         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5638                                                   alc880_models,
5639                                                   alc880_cfg_tbl);
5640         if (board_config < 0) {
5641                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5642                        codec->chip_name);
5643                 board_config = ALC880_AUTO;
5644         }
5645
5646         if (board_config == ALC880_AUTO) {
5647                 /* automatic parse from the BIOS config */
5648                 err = alc880_parse_auto_config(codec);
5649                 if (err < 0) {
5650                         alc_free(codec);
5651                         return err;
5652                 } else if (!err) {
5653                         printk(KERN_INFO
5654                                "hda_codec: Cannot set up configuration "
5655                                "from BIOS.  Using 3-stack mode...\n");
5656                         board_config = ALC880_3ST;
5657                 }
5658         }
5659
5660         err = snd_hda_attach_beep_device(codec, 0x1);
5661         if (err < 0) {
5662                 alc_free(codec);
5663                 return err;
5664         }
5665
5666         if (board_config != ALC880_AUTO)
5667                 setup_preset(codec, &alc880_presets[board_config]);
5668
5669         spec->stream_analog_playback = &alc880_pcm_analog_playback;
5670         spec->stream_analog_capture = &alc880_pcm_analog_capture;
5671         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
5672
5673         spec->stream_digital_playback = &alc880_pcm_digital_playback;
5674         spec->stream_digital_capture = &alc880_pcm_digital_capture;
5675
5676         if (!spec->adc_nids && spec->input_mux) {
5677                 /* check whether NID 0x07 is valid */
5678                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
5679                 /* get type */
5680                 wcap = get_wcaps_type(wcap);
5681                 if (wcap != AC_WID_AUD_IN) {
5682                         spec->adc_nids = alc880_adc_nids_alt;
5683                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
5684                 } else {
5685                         spec->adc_nids = alc880_adc_nids;
5686                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
5687                 }
5688         }
5689         set_capture_mixer(codec);
5690         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5691
5692         spec->vmaster_nid = 0x0c;
5693
5694         codec->patch_ops = alc_patch_ops;
5695         if (board_config == ALC880_AUTO)
5696                 spec->init_hook = alc880_auto_init;
5697 #ifdef CONFIG_SND_HDA_POWER_SAVE
5698         if (!spec->loopback.amplist)
5699                 spec->loopback.amplist = alc880_loopbacks;
5700 #endif
5701
5702         return 0;
5703 }
5704
5705
5706 /*
5707  * ALC260 support
5708  */
5709
5710 static hda_nid_t alc260_dac_nids[1] = {
5711         /* front */
5712         0x02,
5713 };
5714
5715 static hda_nid_t alc260_adc_nids[1] = {
5716         /* ADC0 */
5717         0x04,
5718 };
5719
5720 static hda_nid_t alc260_adc_nids_alt[1] = {
5721         /* ADC1 */
5722         0x05,
5723 };
5724
5725 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5726  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5727  */
5728 static hda_nid_t alc260_dual_adc_nids[2] = {
5729         /* ADC0, ADC1 */
5730         0x04, 0x05
5731 };
5732
5733 #define ALC260_DIGOUT_NID       0x03
5734 #define ALC260_DIGIN_NID        0x06
5735
5736 static struct hda_input_mux alc260_capture_source = {
5737         .num_items = 4,
5738         .items = {
5739                 { "Mic", 0x0 },
5740                 { "Front Mic", 0x1 },
5741                 { "Line", 0x2 },
5742                 { "CD", 0x4 },
5743         },
5744 };
5745
5746 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5747  * headphone jack and the internal CD lines since these are the only pins at
5748  * which audio can appear.  For flexibility, also allow the option of
5749  * recording the mixer output on the second ADC (ADC0 doesn't have a
5750  * connection to the mixer output).
5751  */
5752 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5753         {
5754                 .num_items = 3,
5755                 .items = {
5756                         { "Mic/Line", 0x0 },
5757                         { "CD", 0x4 },
5758                         { "Headphone", 0x2 },
5759                 },
5760         },
5761         {
5762                 .num_items = 4,
5763                 .items = {
5764                         { "Mic/Line", 0x0 },
5765                         { "CD", 0x4 },
5766                         { "Headphone", 0x2 },
5767                         { "Mixer", 0x5 },
5768                 },
5769         },
5770
5771 };
5772
5773 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5774  * the Fujitsu S702x, but jacks are marked differently.
5775  */
5776 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5777         {
5778                 .num_items = 4,
5779                 .items = {
5780                         { "Mic", 0x0 },
5781                         { "Line", 0x2 },
5782                         { "CD", 0x4 },
5783                         { "Headphone", 0x5 },
5784                 },
5785         },
5786         {
5787                 .num_items = 5,
5788                 .items = {
5789                         { "Mic", 0x0 },
5790                         { "Line", 0x2 },
5791                         { "CD", 0x4 },
5792                         { "Headphone", 0x6 },
5793                         { "Mixer", 0x5 },
5794                 },
5795         },
5796 };
5797
5798 /* Maxdata Favorit 100XS */
5799 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5800         {
5801                 .num_items = 2,
5802                 .items = {
5803                         { "Line/Mic", 0x0 },
5804                         { "CD", 0x4 },
5805                 },
5806         },
5807         {
5808                 .num_items = 3,
5809                 .items = {
5810                         { "Line/Mic", 0x0 },
5811                         { "CD", 0x4 },
5812                         { "Mixer", 0x5 },
5813                 },
5814         },
5815 };
5816
5817 /*
5818  * This is just place-holder, so there's something for alc_build_pcms to look
5819  * at when it calculates the maximum number of channels. ALC260 has no mixer
5820  * element which allows changing the channel mode, so the verb list is
5821  * never used.
5822  */
5823 static struct hda_channel_mode alc260_modes[1] = {
5824         { 2, NULL },
5825 };
5826
5827
5828 /* Mixer combinations
5829  *
5830  * basic: base_output + input + pc_beep + capture
5831  * HP: base_output + input + capture_alt
5832  * HP_3013: hp_3013 + input + capture
5833  * fujitsu: fujitsu + capture
5834  * acer: acer + capture
5835  */
5836
5837 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5838         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5839         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5840         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5841         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5842         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5843         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5844         { } /* end */
5845 };
5846
5847 static struct snd_kcontrol_new alc260_input_mixer[] = {
5848         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5849         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5850         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5851         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5852         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5853         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5854         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5855         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5856         { } /* end */
5857 };
5858
5859 /* update HP, line and mono out pins according to the master switch */
5860 static void alc260_hp_master_update(struct hda_codec *codec,
5861                                     hda_nid_t hp, hda_nid_t line,
5862                                     hda_nid_t mono)
5863 {
5864         struct alc_spec *spec = codec->spec;
5865         unsigned int val = spec->master_sw ? PIN_HP : 0;
5866         /* change HP and line-out pins */
5867         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5868                             val);
5869         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5870                             val);
5871         /* mono (speaker) depending on the HP jack sense */
5872         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5873         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5874                             val);
5875 }
5876
5877 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5878                                    struct snd_ctl_elem_value *ucontrol)
5879 {
5880         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5881         struct alc_spec *spec = codec->spec;
5882         *ucontrol->value.integer.value = spec->master_sw;
5883         return 0;
5884 }
5885
5886 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5887                                    struct snd_ctl_elem_value *ucontrol)
5888 {
5889         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5890         struct alc_spec *spec = codec->spec;
5891         int val = !!*ucontrol->value.integer.value;
5892         hda_nid_t hp, line, mono;
5893
5894         if (val == spec->master_sw)
5895                 return 0;
5896         spec->master_sw = val;
5897         hp = (kcontrol->private_value >> 16) & 0xff;
5898         line = (kcontrol->private_value >> 8) & 0xff;
5899         mono = kcontrol->private_value & 0xff;
5900         alc260_hp_master_update(codec, hp, line, mono);
5901         return 1;
5902 }
5903
5904 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5905         {
5906                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5907                 .name = "Master Playback Switch",
5908                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5909                 .info = snd_ctl_boolean_mono_info,
5910                 .get = alc260_hp_master_sw_get,
5911                 .put = alc260_hp_master_sw_put,
5912                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5913         },
5914         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5915         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5916         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5917         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5918         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5919                               HDA_OUTPUT),
5920         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5921         { } /* end */
5922 };
5923
5924 static struct hda_verb alc260_hp_unsol_verbs[] = {
5925         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5926         {},
5927 };
5928
5929 static void alc260_hp_automute(struct hda_codec *codec)
5930 {
5931         struct alc_spec *spec = codec->spec;
5932
5933         spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5934         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5935 }
5936
5937 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5938 {
5939         if ((res >> 26) == ALC880_HP_EVENT)
5940                 alc260_hp_automute(codec);
5941 }
5942
5943 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5944         {
5945                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5946                 .name = "Master Playback Switch",
5947                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5948                 .info = snd_ctl_boolean_mono_info,
5949                 .get = alc260_hp_master_sw_get,
5950                 .put = alc260_hp_master_sw_put,
5951                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5952         },
5953         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5954         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5955         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5956         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5957         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5958         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5959         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5960         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5961         { } /* end */
5962 };
5963
5964 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5965         .ops = &snd_hda_bind_vol,
5966         .values = {
5967                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5968                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5969                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5970                 0
5971         },
5972 };
5973
5974 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5975         .ops = &snd_hda_bind_sw,
5976         .values = {
5977                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5978                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5979                 0
5980         },
5981 };
5982
5983 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5984         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5985         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5986         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5987         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5988         { } /* end */
5989 };
5990
5991 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5992         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5993         {},
5994 };
5995
5996 static void alc260_hp_3013_automute(struct hda_codec *codec)
5997 {
5998         struct alc_spec *spec = codec->spec;
5999
6000         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
6001         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
6002 }
6003
6004 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
6005                                        unsigned int res)
6006 {
6007         if ((res >> 26) == ALC880_HP_EVENT)
6008                 alc260_hp_3013_automute(codec);
6009 }
6010
6011 static void alc260_hp_3012_automute(struct hda_codec *codec)
6012 {
6013         unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
6014
6015         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6016                             bits);
6017         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6018                             bits);
6019         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6020                             bits);
6021 }
6022
6023 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
6024                                        unsigned int res)
6025 {
6026         if ((res >> 26) == ALC880_HP_EVENT)
6027                 alc260_hp_3012_automute(codec);
6028 }
6029
6030 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
6031  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
6032  */
6033 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
6034         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6035         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
6036         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6037         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6038         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6039         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
6040         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
6041         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
6042         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6043         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
6044         { } /* end */
6045 };
6046
6047 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
6048  * versions of the ALC260 don't act on requests to enable mic bias from NID
6049  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
6050  * datasheet doesn't mention this restriction.  At this stage it's not clear
6051  * whether this behaviour is intentional or is a hardware bug in chip
6052  * revisions available in early 2006.  Therefore for now allow the
6053  * "Headphone Jack Mode" control to span all choices, but if it turns out
6054  * that the lack of mic bias for this NID is intentional we could change the
6055  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6056  *
6057  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
6058  * don't appear to make the mic bias available from the "line" jack, even
6059  * though the NID used for this jack (0x14) can supply it.  The theory is
6060  * that perhaps Acer have included blocking capacitors between the ALC260
6061  * and the output jack.  If this turns out to be the case for all such
6062  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
6063  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
6064  *
6065  * The C20x Tablet series have a mono internal speaker which is controlled
6066  * via the chip's Mono sum widget and pin complex, so include the necessary
6067  * controls for such models.  On models without a "mono speaker" the control
6068  * won't do anything.
6069  */
6070 static struct snd_kcontrol_new alc260_acer_mixer[] = {
6071         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6072         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6073         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6074         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
6075                               HDA_OUTPUT),
6076         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
6077                            HDA_INPUT),
6078         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6079         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6080         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6081         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6082         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6083         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6084         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6085         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6086         { } /* end */
6087 };
6088
6089 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
6090  */
6091 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
6092         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6093         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6094         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6095         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6096         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6097         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6098         { } /* end */
6099 };
6100
6101 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
6102  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
6103  */
6104 static struct snd_kcontrol_new alc260_will_mixer[] = {
6105         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6106         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6107         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6108         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6109         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6110         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6111         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6112         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6113         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6114         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6115         { } /* end */
6116 };
6117
6118 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
6119  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
6120  */
6121 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
6122         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6123         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6124         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6125         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6126         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6127         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
6128         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
6129         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6130         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6131         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6132         { } /* end */
6133 };
6134
6135 /*
6136  * initialization verbs
6137  */
6138 static struct hda_verb alc260_init_verbs[] = {
6139         /* Line In pin widget for input */
6140         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6141         /* CD pin widget for input */
6142         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6143         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6144         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6145         /* Mic2 (front panel) pin widget for input and vref at 80% */
6146         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6147         /* LINE-2 is used for line-out in rear */
6148         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6149         /* select line-out */
6150         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
6151         /* LINE-OUT pin */
6152         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6153         /* enable HP */
6154         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6155         /* enable Mono */
6156         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6157         /* mute capture amp left and right */
6158         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6159         /* set connection select to line in (default select for this ADC) */
6160         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6161         /* mute capture amp left and right */
6162         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6163         /* set connection select to line in (default select for this ADC) */
6164         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
6165         /* set vol=0 Line-Out mixer amp left and right */
6166         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6167         /* unmute pin widget amp left and right (no gain on this amp) */
6168         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6169         /* set vol=0 HP mixer amp left and right */
6170         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6171         /* unmute pin widget amp left and right (no gain on this amp) */
6172         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6173         /* set vol=0 Mono mixer amp left and right */
6174         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6175         /* unmute pin widget amp left and right (no gain on this amp) */
6176         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6177         /* unmute LINE-2 out pin */
6178         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6179         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6180          * Line In 2 = 0x03
6181          */
6182         /* mute analog inputs */
6183         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6184         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6185         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6186         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6187         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6188         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6189         /* mute Front out path */
6190         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6191         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6192         /* mute Headphone out path */
6193         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6194         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6195         /* mute Mono out path */
6196         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6197         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6198         { }
6199 };
6200
6201 #if 0 /* should be identical with alc260_init_verbs? */
6202 static struct hda_verb alc260_hp_init_verbs[] = {
6203         /* Headphone and output */
6204         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6205         /* mono output */
6206         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6207         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6208         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6209         /* Mic2 (front panel) pin widget for input and vref at 80% */
6210         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6211         /* Line In pin widget for input */
6212         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6213         /* Line-2 pin widget for output */
6214         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6215         /* CD pin widget for input */
6216         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6217         /* unmute amp left and right */
6218         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6219         /* set connection select to line in (default select for this ADC) */
6220         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6221         /* unmute Line-Out mixer amp left and right (volume = 0) */
6222         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6223         /* mute pin widget amp left and right (no gain on this amp) */
6224         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6225         /* unmute HP mixer amp left and right (volume = 0) */
6226         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6227         /* mute pin widget amp left and right (no gain on this amp) */
6228         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6229         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6230          * Line In 2 = 0x03
6231          */
6232         /* mute analog inputs */
6233         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6234         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6235         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6236         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6237         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6238         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6239         /* Unmute Front out path */
6240         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6241         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6242         /* Unmute Headphone out path */
6243         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6244         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6245         /* Unmute Mono out path */
6246         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6247         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6248         { }
6249 };
6250 #endif
6251
6252 static struct hda_verb alc260_hp_3013_init_verbs[] = {
6253         /* Line out and output */
6254         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6255         /* mono output */
6256         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6257         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6258         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6259         /* Mic2 (front panel) pin widget for input and vref at 80% */
6260         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6261         /* Line In pin widget for input */
6262         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6263         /* Headphone pin widget for output */
6264         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6265         /* CD pin widget for input */
6266         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6267         /* unmute amp left and right */
6268         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6269         /* set connection select to line in (default select for this ADC) */
6270         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6271         /* unmute Line-Out mixer amp left and right (volume = 0) */
6272         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6273         /* mute pin widget amp left and right (no gain on this amp) */
6274         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6275         /* unmute HP mixer amp left and right (volume = 0) */
6276         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6277         /* mute pin widget amp left and right (no gain on this amp) */
6278         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6279         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6280          * Line In 2 = 0x03
6281          */
6282         /* mute analog inputs */
6283         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6284         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6285         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6286         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6287         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6288         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6289         /* Unmute Front out path */
6290         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6291         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6292         /* Unmute Headphone out path */
6293         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6294         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6295         /* Unmute Mono out path */
6296         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6297         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6298         { }
6299 };
6300
6301 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
6302  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
6303  * audio = 0x16, internal speaker = 0x10.
6304  */
6305 static struct hda_verb alc260_fujitsu_init_verbs[] = {
6306         /* Disable all GPIOs */
6307         {0x01, AC_VERB_SET_GPIO_MASK, 0},
6308         /* Internal speaker is connected to headphone pin */
6309         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6310         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
6311         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6312         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
6313         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6314         /* Ensure all other unused pins are disabled and muted. */
6315         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6316         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6317         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6318         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6319         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6320         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6321         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6322         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6323
6324         /* Disable digital (SPDIF) pins */
6325         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6326         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6327
6328         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
6329          * when acting as an output.
6330          */
6331         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6332
6333         /* Start with output sum widgets muted and their output gains at min */
6334         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6335         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6336         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6337         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6338         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6339         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6340         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6341         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6342         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6343
6344         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
6345         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6346         /* Unmute Line1 pin widget output buffer since it starts as an output.
6347          * If the pin mode is changed by the user the pin mode control will
6348          * take care of enabling the pin's input/output buffers as needed.
6349          * Therefore there's no need to enable the input buffer at this
6350          * stage.
6351          */
6352         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6353         /* Unmute input buffer of pin widget used for Line-in (no equiv
6354          * mixer ctrl)
6355          */
6356         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6357
6358         /* Mute capture amp left and right */
6359         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6360         /* Set ADC connection select to match default mixer setting - line
6361          * in (on mic1 pin)
6362          */
6363         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6364
6365         /* Do the same for the second ADC: mute capture input amp and
6366          * set ADC connection to line in (on mic1 pin)
6367          */
6368         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6369         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6370
6371         /* Mute all inputs to mixer widget (even unconnected ones) */
6372         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6373         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6374         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6375         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6376         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6377         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6378         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6379         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6380
6381         { }
6382 };
6383
6384 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
6385  * similar laptops (adapted from Fujitsu init verbs).
6386  */
6387 static struct hda_verb alc260_acer_init_verbs[] = {
6388         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
6389          * the headphone jack.  Turn this on and rely on the standard mute
6390          * methods whenever the user wants to turn these outputs off.
6391          */
6392         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6393         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6394         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6395         /* Internal speaker/Headphone jack is connected to Line-out pin */
6396         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6397         /* Internal microphone/Mic jack is connected to Mic1 pin */
6398         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6399         /* Line In jack is connected to Line1 pin */
6400         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6401         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
6402         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6403         /* Ensure all other unused pins are disabled and muted. */
6404         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6405         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6406         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6407         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6408         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6409         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6410         /* Disable digital (SPDIF) pins */
6411         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6412         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6413
6414         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6415          * bus when acting as outputs.
6416          */
6417         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6418         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6419
6420         /* Start with output sum widgets muted and their output gains at min */
6421         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6422         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6423         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6424         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6425         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6426         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6427         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6428         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6429         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6430
6431         /* Unmute Line-out pin widget amp left and right
6432          * (no equiv mixer ctrl)
6433          */
6434         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6435         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
6436         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6437         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6438          * inputs. If the pin mode is changed by the user the pin mode control
6439          * will take care of enabling the pin's input/output buffers as needed.
6440          * Therefore there's no need to enable the input buffer at this
6441          * stage.
6442          */
6443         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6444         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6445
6446         /* Mute capture amp left and right */
6447         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6448         /* Set ADC connection select to match default mixer setting - mic
6449          * (on mic1 pin)
6450          */
6451         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6452
6453         /* Do similar with the second ADC: mute capture input amp and
6454          * set ADC connection to mic to match ALSA's default state.
6455          */
6456         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6457         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6458
6459         /* Mute all inputs to mixer widget (even unconnected ones) */
6460         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6461         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6462         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6463         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6464         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6465         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6466         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6467         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6468
6469         { }
6470 };
6471
6472 /* Initialisation sequence for Maxdata Favorit 100XS
6473  * (adapted from Acer init verbs).
6474  */
6475 static struct hda_verb alc260_favorit100_init_verbs[] = {
6476         /* GPIO 0 enables the output jack.
6477          * Turn this on and rely on the standard mute
6478          * methods whenever the user wants to turn these outputs off.
6479          */
6480         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6481         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6482         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6483         /* Line/Mic input jack is connected to Mic1 pin */
6484         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6485         /* Ensure all other unused pins are disabled and muted. */
6486         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6487         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6488         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6489         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6490         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6491         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6492         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6493         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6494         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6495         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6496         /* Disable digital (SPDIF) pins */
6497         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6498         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6499
6500         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6501          * bus when acting as outputs.
6502          */
6503         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6504         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6505
6506         /* Start with output sum widgets muted and their output gains at min */
6507         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6508         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6509         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6510         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6511         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6512         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6513         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6514         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6515         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6516
6517         /* Unmute Line-out pin widget amp left and right
6518          * (no equiv mixer ctrl)
6519          */
6520         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6521         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6522          * inputs. If the pin mode is changed by the user the pin mode control
6523          * will take care of enabling the pin's input/output buffers as needed.
6524          * Therefore there's no need to enable the input buffer at this
6525          * stage.
6526          */
6527         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6528
6529         /* Mute capture amp left and right */
6530         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6531         /* Set ADC connection select to match default mixer setting - mic
6532          * (on mic1 pin)
6533          */
6534         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6535
6536         /* Do similar with the second ADC: mute capture input amp and
6537          * set ADC connection to mic to match ALSA's default state.
6538          */
6539         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6540         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6541
6542         /* Mute all inputs to mixer widget (even unconnected ones) */
6543         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6544         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6545         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6546         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6547         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6548         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6549         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6550         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6551
6552         { }
6553 };
6554
6555 static struct hda_verb alc260_will_verbs[] = {
6556         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6557         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6558         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6559         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6560         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6561         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6562         {}
6563 };
6564
6565 static struct hda_verb alc260_replacer_672v_verbs[] = {
6566         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6567         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6568         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6569
6570         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6571         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6572         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6573
6574         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6575         {}
6576 };
6577
6578 /* toggle speaker-output according to the hp-jack state */
6579 static void alc260_replacer_672v_automute(struct hda_codec *codec)
6580 {
6581         unsigned int present;
6582
6583         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6584         present = snd_hda_jack_detect(codec, 0x0f);
6585         if (present) {
6586                 snd_hda_codec_write_cache(codec, 0x01, 0,
6587                                           AC_VERB_SET_GPIO_DATA, 1);
6588                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6589                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6590                                           PIN_HP);
6591         } else {
6592                 snd_hda_codec_write_cache(codec, 0x01, 0,
6593                                           AC_VERB_SET_GPIO_DATA, 0);
6594                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6595                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6596                                           PIN_OUT);
6597         }
6598 }
6599
6600 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6601                                        unsigned int res)
6602 {
6603         if ((res >> 26) == ALC880_HP_EVENT)
6604                 alc260_replacer_672v_automute(codec);
6605 }
6606
6607 static struct hda_verb alc260_hp_dc7600_verbs[] = {
6608         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6609         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6610         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6611         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6612         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6613         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6614         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6615         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6616         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6617         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6618         {}
6619 };
6620
6621 /* Test configuration for debugging, modelled after the ALC880 test
6622  * configuration.
6623  */
6624 #ifdef CONFIG_SND_DEBUG
6625 static hda_nid_t alc260_test_dac_nids[1] = {
6626         0x02,
6627 };
6628 static hda_nid_t alc260_test_adc_nids[2] = {
6629         0x04, 0x05,
6630 };
6631 /* For testing the ALC260, each input MUX needs its own definition since
6632  * the signal assignments are different.  This assumes that the first ADC
6633  * is NID 0x04.
6634  */
6635 static struct hda_input_mux alc260_test_capture_sources[2] = {
6636         {
6637                 .num_items = 7,
6638                 .items = {
6639                         { "MIC1 pin", 0x0 },
6640                         { "MIC2 pin", 0x1 },
6641                         { "LINE1 pin", 0x2 },
6642                         { "LINE2 pin", 0x3 },
6643                         { "CD pin", 0x4 },
6644                         { "LINE-OUT pin", 0x5 },
6645                         { "HP-OUT pin", 0x6 },
6646                 },
6647         },
6648         {
6649                 .num_items = 8,
6650                 .items = {
6651                         { "MIC1 pin", 0x0 },
6652                         { "MIC2 pin", 0x1 },
6653                         { "LINE1 pin", 0x2 },
6654                         { "LINE2 pin", 0x3 },
6655                         { "CD pin", 0x4 },
6656                         { "Mixer", 0x5 },
6657                         { "LINE-OUT pin", 0x6 },
6658                         { "HP-OUT pin", 0x7 },
6659                 },
6660         },
6661 };
6662 static struct snd_kcontrol_new alc260_test_mixer[] = {
6663         /* Output driver widgets */
6664         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6665         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6666         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6667         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6668         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6669         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6670
6671         /* Modes for retasking pin widgets
6672          * Note: the ALC260 doesn't seem to act on requests to enable mic
6673          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6674          * mention this restriction.  At this stage it's not clear whether
6675          * this behaviour is intentional or is a hardware bug in chip
6676          * revisions available at least up until early 2006.  Therefore for
6677          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6678          * choices, but if it turns out that the lack of mic bias for these
6679          * NIDs is intentional we could change their modes from
6680          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6681          */
6682         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6683         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6684         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
6685         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
6686         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
6687         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
6688
6689         /* Loopback mixer controls */
6690         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
6691         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
6692         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
6693         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
6694         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
6695         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
6696         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
6697         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
6698         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6699         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6700         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
6701         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
6702         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
6703         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
6704
6705         /* Controls for GPIO pins, assuming they are configured as outputs */
6706         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
6707         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
6708         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
6709         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
6710
6711         /* Switches to allow the digital IO pins to be enabled.  The datasheet
6712          * is ambigious as to which NID is which; testing on laptops which
6713          * make this output available should provide clarification.
6714          */
6715         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
6716         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
6717
6718         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
6719          * this output to turn on an external amplifier.
6720          */
6721         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
6722         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
6723
6724         { } /* end */
6725 };
6726 static struct hda_verb alc260_test_init_verbs[] = {
6727         /* Enable all GPIOs as outputs with an initial value of 0 */
6728         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6729         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6730         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6731
6732         /* Enable retasking pins as output, initially without power amp */
6733         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6734         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6735         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6736         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6737         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6738         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6739
6740         /* Disable digital (SPDIF) pins initially, but users can enable
6741          * them via a mixer switch.  In the case of SPDIF-out, this initverb
6742          * payload also sets the generation to 0, output to be in "consumer"
6743          * PCM format, copyright asserted, no pre-emphasis and no validity
6744          * control.
6745          */
6746         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6747         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6748
6749         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6750          * OUT1 sum bus when acting as an output.
6751          */
6752         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6753         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6754         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6755         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6756
6757         /* Start with output sum widgets muted and their output gains at min */
6758         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6759         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6760         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6761         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6762         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6763         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6764         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6765         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6766         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6767
6768         /* Unmute retasking pin widget output buffers since the default
6769          * state appears to be output.  As the pin mode is changed by the
6770          * user the pin mode control will take care of enabling the pin's
6771          * input/output buffers as needed.
6772          */
6773         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6774         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6775         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6776         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6777         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6778         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6779         /* Also unmute the mono-out pin widget */
6780         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6781
6782         /* Mute capture amp left and right */
6783         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6784         /* Set ADC connection select to match default mixer setting (mic1
6785          * pin)
6786          */
6787         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6788
6789         /* Do the same for the second ADC: mute capture input amp and
6790          * set ADC connection to mic1 pin
6791          */
6792         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6793         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6794
6795         /* Mute all inputs to mixer widget (even unconnected ones) */
6796         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6797         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6798         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6799         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6800         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6801         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6802         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6803         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6804
6805         { }
6806 };
6807 #endif
6808
6809 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
6810 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
6811
6812 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
6813 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
6814
6815 /*
6816  * for BIOS auto-configuration
6817  */
6818
6819 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6820                                         const char *pfx, int *vol_bits)
6821 {
6822         hda_nid_t nid_vol;
6823         unsigned long vol_val, sw_val;
6824         int err;
6825
6826         if (nid >= 0x0f && nid < 0x11) {
6827                 nid_vol = nid - 0x7;
6828                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6829                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6830         } else if (nid == 0x11) {
6831                 nid_vol = nid - 0x7;
6832                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6833                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6834         } else if (nid >= 0x12 && nid <= 0x15) {
6835                 nid_vol = 0x08;
6836                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6837                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6838         } else
6839                 return 0; /* N/A */
6840
6841         if (!(*vol_bits & (1 << nid_vol))) {
6842                 /* first control for the volume widget */
6843                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6844                 if (err < 0)
6845                         return err;
6846                 *vol_bits |= (1 << nid_vol);
6847         }
6848         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6849         if (err < 0)
6850                 return err;
6851         return 1;
6852 }
6853
6854 /* add playback controls from the parsed DAC table */
6855 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6856                                              const struct auto_pin_cfg *cfg)
6857 {
6858         hda_nid_t nid;
6859         int err;
6860         int vols = 0;
6861
6862         spec->multiout.num_dacs = 1;
6863         spec->multiout.dac_nids = spec->private_dac_nids;
6864         spec->multiout.dac_nids[0] = 0x02;
6865
6866         nid = cfg->line_out_pins[0];
6867         if (nid) {
6868                 const char *pfx;
6869                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6870                         pfx = "Master";
6871                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6872                         pfx = "Speaker";
6873                 else
6874                         pfx = "Front";
6875                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6876                 if (err < 0)
6877                         return err;
6878         }
6879
6880         nid = cfg->speaker_pins[0];
6881         if (nid) {
6882                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6883                 if (err < 0)
6884                         return err;
6885         }
6886
6887         nid = cfg->hp_pins[0];
6888         if (nid) {
6889                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6890                                                    &vols);
6891                 if (err < 0)
6892                         return err;
6893         }
6894         return 0;
6895 }
6896
6897 /* create playback/capture controls for input pins */
6898 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6899                                                 const struct auto_pin_cfg *cfg)
6900 {
6901         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6902 }
6903
6904 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6905                                               hda_nid_t nid, int pin_type,
6906                                               int sel_idx)
6907 {
6908         alc_set_pin_output(codec, nid, pin_type);
6909         /* need the manual connection? */
6910         if (nid >= 0x12) {
6911                 int idx = nid - 0x12;
6912                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6913                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6914         }
6915 }
6916
6917 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6918 {
6919         struct alc_spec *spec = codec->spec;
6920         hda_nid_t nid;
6921
6922         nid = spec->autocfg.line_out_pins[0];
6923         if (nid) {
6924                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6925                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6926         }
6927
6928         nid = spec->autocfg.speaker_pins[0];
6929         if (nid)
6930                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6931
6932         nid = spec->autocfg.hp_pins[0];
6933         if (nid)
6934                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6935 }
6936
6937 #define ALC260_PIN_CD_NID               0x16
6938 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6939 {
6940         struct alc_spec *spec = codec->spec;
6941         struct auto_pin_cfg *cfg = &spec->autocfg;
6942         int i;
6943
6944         for (i = 0; i < cfg->num_inputs; i++) {
6945                 hda_nid_t nid = cfg->inputs[i].pin;
6946                 if (nid >= 0x12) {
6947                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
6948                         if (nid != ALC260_PIN_CD_NID &&
6949                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6950                                 snd_hda_codec_write(codec, nid, 0,
6951                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6952                                                     AMP_OUT_MUTE);
6953                 }
6954         }
6955 }
6956
6957 #define alc260_auto_init_input_src      alc880_auto_init_input_src
6958
6959 /*
6960  * generic initialization of ADC, input mixers and output mixers
6961  */
6962 static struct hda_verb alc260_volume_init_verbs[] = {
6963         /*
6964          * Unmute ADC0-1 and set the default input to mic-in
6965          */
6966         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6967         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6968         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6969         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6970
6971         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6972          * mixer widget
6973          * Note: PASD motherboards uses the Line In 2 as the input for
6974          * front panel mic (mic 2)
6975          */
6976         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6977         /* mute analog inputs */
6978         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6979         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6980         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6981         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6982         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6983
6984         /*
6985          * Set up output mixers (0x08 - 0x0a)
6986          */
6987         /* set vol=0 to output mixers */
6988         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6989         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6990         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6991         /* set up input amps for analog loopback */
6992         /* Amp Indices: DAC = 0, mixer = 1 */
6993         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6994         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6995         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6996         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6997         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6998         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6999
7000         { }
7001 };
7002
7003 static int alc260_parse_auto_config(struct hda_codec *codec)
7004 {
7005         struct alc_spec *spec = codec->spec;
7006         int err;
7007         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
7008
7009         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
7010                                            alc260_ignore);
7011         if (err < 0)
7012                 return err;
7013         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
7014         if (err < 0)
7015                 return err;
7016         if (!spec->kctls.list)
7017                 return 0; /* can't find valid BIOS pin config */
7018         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
7019         if (err < 0)
7020                 return err;
7021
7022         spec->multiout.max_channels = 2;
7023
7024         if (spec->autocfg.dig_outs)
7025                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
7026         if (spec->kctls.list)
7027                 add_mixer(spec, spec->kctls.list);
7028
7029         add_verb(spec, alc260_volume_init_verbs);
7030
7031         spec->num_mux_defs = 1;
7032         spec->input_mux = &spec->private_imux[0];
7033
7034         alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
7035
7036         return 1;
7037 }
7038
7039 /* additional initialization for auto-configuration model */
7040 static void alc260_auto_init(struct hda_codec *codec)
7041 {
7042         struct alc_spec *spec = codec->spec;
7043         alc260_auto_init_multi_out(codec);
7044         alc260_auto_init_analog_input(codec);
7045         alc260_auto_init_input_src(codec);
7046         alc_auto_init_digital(codec);
7047         if (spec->unsol_event)
7048                 alc_inithook(codec);
7049 }
7050
7051 #ifdef CONFIG_SND_HDA_POWER_SAVE
7052 static struct hda_amp_list alc260_loopbacks[] = {
7053         { 0x07, HDA_INPUT, 0 },
7054         { 0x07, HDA_INPUT, 1 },
7055         { 0x07, HDA_INPUT, 2 },
7056         { 0x07, HDA_INPUT, 3 },
7057         { 0x07, HDA_INPUT, 4 },
7058         { } /* end */
7059 };
7060 #endif
7061
7062 /*
7063  * Pin config fixes
7064  */
7065 enum {
7066         PINFIX_HP_DC5750,
7067 };
7068
7069 static const struct alc_fixup alc260_fixups[] = {
7070         [PINFIX_HP_DC5750] = {
7071                 .pins = (const struct alc_pincfg[]) {
7072                         { 0x11, 0x90130110 }, /* speaker */
7073                         { }
7074                 }
7075         },
7076 };
7077
7078 static struct snd_pci_quirk alc260_fixup_tbl[] = {
7079         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
7080         {}
7081 };
7082
7083 /*
7084  * ALC260 configurations
7085  */
7086 static const char *alc260_models[ALC260_MODEL_LAST] = {
7087         [ALC260_BASIC]          = "basic",
7088         [ALC260_HP]             = "hp",
7089         [ALC260_HP_3013]        = "hp-3013",
7090         [ALC260_HP_DC7600]      = "hp-dc7600",
7091         [ALC260_FUJITSU_S702X]  = "fujitsu",
7092         [ALC260_ACER]           = "acer",
7093         [ALC260_WILL]           = "will",
7094         [ALC260_REPLACER_672V]  = "replacer",
7095         [ALC260_FAVORIT100]     = "favorit100",
7096 #ifdef CONFIG_SND_DEBUG
7097         [ALC260_TEST]           = "test",
7098 #endif
7099         [ALC260_AUTO]           = "auto",
7100 };
7101
7102 static struct snd_pci_quirk alc260_cfg_tbl[] = {
7103         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
7104         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
7105         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
7106         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
7107         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
7108         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
7109         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
7110         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
7111         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
7112         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
7113         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
7114         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
7115         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
7116         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
7117         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
7118         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
7119         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
7120         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
7121         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
7122         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
7123         {}
7124 };
7125
7126 static struct alc_config_preset alc260_presets[] = {
7127         [ALC260_BASIC] = {
7128                 .mixers = { alc260_base_output_mixer,
7129                             alc260_input_mixer },
7130                 .init_verbs = { alc260_init_verbs },
7131                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7132                 .dac_nids = alc260_dac_nids,
7133                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7134                 .adc_nids = alc260_dual_adc_nids,
7135                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7136                 .channel_mode = alc260_modes,
7137                 .input_mux = &alc260_capture_source,
7138         },
7139         [ALC260_HP] = {
7140                 .mixers = { alc260_hp_output_mixer,
7141                             alc260_input_mixer },
7142                 .init_verbs = { alc260_init_verbs,
7143                                 alc260_hp_unsol_verbs },
7144                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7145                 .dac_nids = alc260_dac_nids,
7146                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7147                 .adc_nids = alc260_adc_nids_alt,
7148                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7149                 .channel_mode = alc260_modes,
7150                 .input_mux = &alc260_capture_source,
7151                 .unsol_event = alc260_hp_unsol_event,
7152                 .init_hook = alc260_hp_automute,
7153         },
7154         [ALC260_HP_DC7600] = {
7155                 .mixers = { alc260_hp_dc7600_mixer,
7156                             alc260_input_mixer },
7157                 .init_verbs = { alc260_init_verbs,
7158                                 alc260_hp_dc7600_verbs },
7159                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7160                 .dac_nids = alc260_dac_nids,
7161                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7162                 .adc_nids = alc260_adc_nids_alt,
7163                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7164                 .channel_mode = alc260_modes,
7165                 .input_mux = &alc260_capture_source,
7166                 .unsol_event = alc260_hp_3012_unsol_event,
7167                 .init_hook = alc260_hp_3012_automute,
7168         },
7169         [ALC260_HP_3013] = {
7170                 .mixers = { alc260_hp_3013_mixer,
7171                             alc260_input_mixer },
7172                 .init_verbs = { alc260_hp_3013_init_verbs,
7173                                 alc260_hp_3013_unsol_verbs },
7174                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7175                 .dac_nids = alc260_dac_nids,
7176                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7177                 .adc_nids = alc260_adc_nids_alt,
7178                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7179                 .channel_mode = alc260_modes,
7180                 .input_mux = &alc260_capture_source,
7181                 .unsol_event = alc260_hp_3013_unsol_event,
7182                 .init_hook = alc260_hp_3013_automute,
7183         },
7184         [ALC260_FUJITSU_S702X] = {
7185                 .mixers = { alc260_fujitsu_mixer },
7186                 .init_verbs = { alc260_fujitsu_init_verbs },
7187                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7188                 .dac_nids = alc260_dac_nids,
7189                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7190                 .adc_nids = alc260_dual_adc_nids,
7191                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7192                 .channel_mode = alc260_modes,
7193                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
7194                 .input_mux = alc260_fujitsu_capture_sources,
7195         },
7196         [ALC260_ACER] = {
7197                 .mixers = { alc260_acer_mixer },
7198                 .init_verbs = { alc260_acer_init_verbs },
7199                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7200                 .dac_nids = alc260_dac_nids,
7201                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7202                 .adc_nids = alc260_dual_adc_nids,
7203                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7204                 .channel_mode = alc260_modes,
7205                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
7206                 .input_mux = alc260_acer_capture_sources,
7207         },
7208         [ALC260_FAVORIT100] = {
7209                 .mixers = { alc260_favorit100_mixer },
7210                 .init_verbs = { alc260_favorit100_init_verbs },
7211                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7212                 .dac_nids = alc260_dac_nids,
7213                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7214                 .adc_nids = alc260_dual_adc_nids,
7215                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7216                 .channel_mode = alc260_modes,
7217                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
7218                 .input_mux = alc260_favorit100_capture_sources,
7219         },
7220         [ALC260_WILL] = {
7221                 .mixers = { alc260_will_mixer },
7222                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
7223                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7224                 .dac_nids = alc260_dac_nids,
7225                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7226                 .adc_nids = alc260_adc_nids,
7227                 .dig_out_nid = ALC260_DIGOUT_NID,
7228                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7229                 .channel_mode = alc260_modes,
7230                 .input_mux = &alc260_capture_source,
7231         },
7232         [ALC260_REPLACER_672V] = {
7233                 .mixers = { alc260_replacer_672v_mixer },
7234                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
7235                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7236                 .dac_nids = alc260_dac_nids,
7237                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7238                 .adc_nids = alc260_adc_nids,
7239                 .dig_out_nid = ALC260_DIGOUT_NID,
7240                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7241                 .channel_mode = alc260_modes,
7242                 .input_mux = &alc260_capture_source,
7243                 .unsol_event = alc260_replacer_672v_unsol_event,
7244                 .init_hook = alc260_replacer_672v_automute,
7245         },
7246 #ifdef CONFIG_SND_DEBUG
7247         [ALC260_TEST] = {
7248                 .mixers = { alc260_test_mixer },
7249                 .init_verbs = { alc260_test_init_verbs },
7250                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
7251                 .dac_nids = alc260_test_dac_nids,
7252                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
7253                 .adc_nids = alc260_test_adc_nids,
7254                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7255                 .channel_mode = alc260_modes,
7256                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
7257                 .input_mux = alc260_test_capture_sources,
7258         },
7259 #endif
7260 };
7261
7262 static int patch_alc260(struct hda_codec *codec)
7263 {
7264         struct alc_spec *spec;
7265         int err, board_config;
7266
7267         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7268         if (spec == NULL)
7269                 return -ENOMEM;
7270
7271         codec->spec = spec;
7272
7273         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
7274                                                   alc260_models,
7275                                                   alc260_cfg_tbl);
7276         if (board_config < 0) {
7277                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
7278                            codec->chip_name);
7279                 board_config = ALC260_AUTO;
7280         }
7281
7282         if (board_config == ALC260_AUTO)
7283                 alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 1);
7284
7285         if (board_config == ALC260_AUTO) {
7286                 /* automatic parse from the BIOS config */
7287                 err = alc260_parse_auto_config(codec);
7288                 if (err < 0) {
7289                         alc_free(codec);
7290                         return err;
7291                 } else if (!err) {
7292                         printk(KERN_INFO
7293                                "hda_codec: Cannot set up configuration "
7294                                "from BIOS.  Using base mode...\n");
7295                         board_config = ALC260_BASIC;
7296                 }
7297         }
7298
7299         err = snd_hda_attach_beep_device(codec, 0x1);
7300         if (err < 0) {
7301                 alc_free(codec);
7302                 return err;
7303         }
7304
7305         if (board_config != ALC260_AUTO)
7306                 setup_preset(codec, &alc260_presets[board_config]);
7307
7308         spec->stream_analog_playback = &alc260_pcm_analog_playback;
7309         spec->stream_analog_capture = &alc260_pcm_analog_capture;
7310         spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
7311
7312         spec->stream_digital_playback = &alc260_pcm_digital_playback;
7313         spec->stream_digital_capture = &alc260_pcm_digital_capture;
7314
7315         if (!spec->adc_nids && spec->input_mux) {
7316                 /* check whether NID 0x04 is valid */
7317                 unsigned int wcap = get_wcaps(codec, 0x04);
7318                 wcap = get_wcaps_type(wcap);
7319                 /* get type */
7320                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
7321                         spec->adc_nids = alc260_adc_nids_alt;
7322                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
7323                 } else {
7324                         spec->adc_nids = alc260_adc_nids;
7325                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
7326                 }
7327         }
7328         set_capture_mixer(codec);
7329         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
7330
7331         if (board_config == ALC260_AUTO)
7332                 alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 0);
7333
7334         spec->vmaster_nid = 0x08;
7335
7336         codec->patch_ops = alc_patch_ops;
7337         if (board_config == ALC260_AUTO)
7338                 spec->init_hook = alc260_auto_init;
7339 #ifdef CONFIG_SND_HDA_POWER_SAVE
7340         if (!spec->loopback.amplist)
7341                 spec->loopback.amplist = alc260_loopbacks;
7342 #endif
7343
7344         return 0;
7345 }
7346
7347
7348 /*
7349  * ALC882/883/885/888/889 support
7350  *
7351  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
7352  * configuration.  Each pin widget can choose any input DACs and a mixer.
7353  * Each ADC is connected from a mixer of all inputs.  This makes possible
7354  * 6-channel independent captures.
7355  *
7356  * In addition, an independent DAC for the multi-playback (not used in this
7357  * driver yet).
7358  */
7359 #define ALC882_DIGOUT_NID       0x06
7360 #define ALC882_DIGIN_NID        0x0a
7361 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
7362 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
7363 #define ALC1200_DIGOUT_NID      0x10
7364
7365
7366 static struct hda_channel_mode alc882_ch_modes[1] = {
7367         { 8, NULL }
7368 };
7369
7370 /* DACs */
7371 static hda_nid_t alc882_dac_nids[4] = {
7372         /* front, rear, clfe, rear_surr */
7373         0x02, 0x03, 0x04, 0x05
7374 };
7375 #define alc883_dac_nids         alc882_dac_nids
7376
7377 /* ADCs */
7378 #define alc882_adc_nids         alc880_adc_nids
7379 #define alc882_adc_nids_alt     alc880_adc_nids_alt
7380 #define alc883_adc_nids         alc882_adc_nids_alt
7381 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
7382 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
7383 #define alc889_adc_nids         alc880_adc_nids
7384
7385 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
7386 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
7387 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
7388 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7389 #define alc889_capsrc_nids      alc882_capsrc_nids
7390
7391 /* input MUX */
7392 /* FIXME: should be a matrix-type input source selection */
7393
7394 static struct hda_input_mux alc882_capture_source = {
7395         .num_items = 4,
7396         .items = {
7397                 { "Mic", 0x0 },
7398                 { "Front Mic", 0x1 },
7399                 { "Line", 0x2 },
7400                 { "CD", 0x4 },
7401         },
7402 };
7403
7404 #define alc883_capture_source   alc882_capture_source
7405
7406 static struct hda_input_mux alc889_capture_source = {
7407         .num_items = 3,
7408         .items = {
7409                 { "Front Mic", 0x0 },
7410                 { "Mic", 0x3 },
7411                 { "Line", 0x2 },
7412         },
7413 };
7414
7415 static struct hda_input_mux mb5_capture_source = {
7416         .num_items = 3,
7417         .items = {
7418                 { "Mic", 0x1 },
7419                 { "Line", 0x7 },
7420                 { "CD", 0x4 },
7421         },
7422 };
7423
7424 static struct hda_input_mux macmini3_capture_source = {
7425         .num_items = 2,
7426         .items = {
7427                 { "Line", 0x2 },
7428                 { "CD", 0x4 },
7429         },
7430 };
7431
7432 static struct hda_input_mux alc883_3stack_6ch_intel = {
7433         .num_items = 4,
7434         .items = {
7435                 { "Mic", 0x1 },
7436                 { "Front Mic", 0x0 },
7437                 { "Line", 0x2 },
7438                 { "CD", 0x4 },
7439         },
7440 };
7441
7442 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7443         .num_items = 2,
7444         .items = {
7445                 { "Mic", 0x1 },
7446                 { "Line", 0x2 },
7447         },
7448 };
7449
7450 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7451         .num_items = 4,
7452         .items = {
7453                 { "Mic", 0x0 },
7454                 { "Int Mic", 0x1 },
7455                 { "Line", 0x2 },
7456                 { "CD", 0x4 },
7457         },
7458 };
7459
7460 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7461         .num_items = 2,
7462         .items = {
7463                 { "Mic", 0x0 },
7464                 { "Int Mic", 0x1 },
7465         },
7466 };
7467
7468 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7469         .num_items = 3,
7470         .items = {
7471                 { "Mic", 0x0 },
7472                 { "Front Mic", 0x1 },
7473                 { "Line", 0x4 },
7474         },
7475 };
7476
7477 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7478         .num_items = 2,
7479         .items = {
7480                 { "Mic", 0x0 },
7481                 { "Line", 0x2 },
7482         },
7483 };
7484
7485 static struct hda_input_mux alc889A_mb31_capture_source = {
7486         .num_items = 2,
7487         .items = {
7488                 { "Mic", 0x0 },
7489                 /* Front Mic (0x01) unused */
7490                 { "Line", 0x2 },
7491                 /* Line 2 (0x03) unused */
7492                 /* CD (0x04) unused? */
7493         },
7494 };
7495
7496 static struct hda_input_mux alc889A_imac91_capture_source = {
7497         .num_items = 2,
7498         .items = {
7499                 { "Mic", 0x01 },
7500                 { "Line", 0x2 }, /* Not sure! */
7501         },
7502 };
7503
7504 /*
7505  * 2ch mode
7506  */
7507 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7508         { 2, NULL }
7509 };
7510
7511 /*
7512  * 2ch mode
7513  */
7514 static struct hda_verb alc882_3ST_ch2_init[] = {
7515         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7516         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7517         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7518         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7519         { } /* end */
7520 };
7521
7522 /*
7523  * 4ch mode
7524  */
7525 static struct hda_verb alc882_3ST_ch4_init[] = {
7526         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7527         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7528         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7529         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7530         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7531         { } /* end */
7532 };
7533
7534 /*
7535  * 6ch mode
7536  */
7537 static struct hda_verb alc882_3ST_ch6_init[] = {
7538         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7539         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7540         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7541         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7542         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7543         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7544         { } /* end */
7545 };
7546
7547 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
7548         { 2, alc882_3ST_ch2_init },
7549         { 4, alc882_3ST_ch4_init },
7550         { 6, alc882_3ST_ch6_init },
7551 };
7552
7553 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
7554
7555 /*
7556  * 2ch mode
7557  */
7558 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
7559         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
7560         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7561         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7562         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7563         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7564         { } /* end */
7565 };
7566
7567 /*
7568  * 4ch mode
7569  */
7570 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
7571         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7572         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7573         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7574         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7575         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7576         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7577         { } /* end */
7578 };
7579
7580 /*
7581  * 6ch mode
7582  */
7583 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
7584         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7585         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7586         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7587         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7588         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7589         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7590         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7591         { } /* end */
7592 };
7593
7594 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
7595         { 2, alc883_3ST_ch2_clevo_init },
7596         { 4, alc883_3ST_ch4_clevo_init },
7597         { 6, alc883_3ST_ch6_clevo_init },
7598 };
7599
7600
7601 /*
7602  * 6ch mode
7603  */
7604 static struct hda_verb alc882_sixstack_ch6_init[] = {
7605         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7606         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7607         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7608         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7609         { } /* end */
7610 };
7611
7612 /*
7613  * 8ch mode
7614  */
7615 static struct hda_verb alc882_sixstack_ch8_init[] = {
7616         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7617         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7618         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7619         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7620         { } /* end */
7621 };
7622
7623 static struct hda_channel_mode alc882_sixstack_modes[2] = {
7624         { 6, alc882_sixstack_ch6_init },
7625         { 8, alc882_sixstack_ch8_init },
7626 };
7627
7628
7629 /* Macbook Air 2,1 */
7630
7631 static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7632       { 2, NULL },
7633 };
7634
7635 /*
7636  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7637  */
7638
7639 /*
7640  * 2ch mode
7641  */
7642 static struct hda_verb alc885_mbp_ch2_init[] = {
7643         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7644         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7645         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7646         { } /* end */
7647 };
7648
7649 /*
7650  * 4ch mode
7651  */
7652 static struct hda_verb alc885_mbp_ch4_init[] = {
7653         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7654         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7655         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7656         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7657         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7658         { } /* end */
7659 };
7660
7661 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7662         { 2, alc885_mbp_ch2_init },
7663         { 4, alc885_mbp_ch4_init },
7664 };
7665
7666 /*
7667  * 2ch
7668  * Speakers/Woofer/HP = Front
7669  * LineIn = Input
7670  */
7671 static struct hda_verb alc885_mb5_ch2_init[] = {
7672         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7673         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7674         { } /* end */
7675 };
7676
7677 /*
7678  * 6ch mode
7679  * Speakers/HP = Front
7680  * Woofer = LFE
7681  * LineIn = Surround
7682  */
7683 static struct hda_verb alc885_mb5_ch6_init[] = {
7684         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7685         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7686         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7687         { } /* end */
7688 };
7689
7690 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
7691         { 2, alc885_mb5_ch2_init },
7692         { 6, alc885_mb5_ch6_init },
7693 };
7694
7695 #define alc885_macmini3_6ch_modes       alc885_mb5_6ch_modes
7696
7697 /*
7698  * 2ch mode
7699  */
7700 static struct hda_verb alc883_4ST_ch2_init[] = {
7701         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7702         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7703         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7704         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7705         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7706         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7707         { } /* end */
7708 };
7709
7710 /*
7711  * 4ch mode
7712  */
7713 static struct hda_verb alc883_4ST_ch4_init[] = {
7714         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7715         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7716         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7717         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7718         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7719         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7720         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7721         { } /* end */
7722 };
7723
7724 /*
7725  * 6ch mode
7726  */
7727 static struct hda_verb alc883_4ST_ch6_init[] = {
7728         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7729         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7730         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7731         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7732         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7733         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7734         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7735         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7736         { } /* end */
7737 };
7738
7739 /*
7740  * 8ch mode
7741  */
7742 static struct hda_verb alc883_4ST_ch8_init[] = {
7743         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7744         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7745         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7746         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7747         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7748         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7749         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7750         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7751         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7752         { } /* end */
7753 };
7754
7755 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
7756         { 2, alc883_4ST_ch2_init },
7757         { 4, alc883_4ST_ch4_init },
7758         { 6, alc883_4ST_ch6_init },
7759         { 8, alc883_4ST_ch8_init },
7760 };
7761
7762
7763 /*
7764  * 2ch mode
7765  */
7766 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7767         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7768         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7769         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7770         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7771         { } /* end */
7772 };
7773
7774 /*
7775  * 4ch mode
7776  */
7777 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7778         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7779         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7780         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7781         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7782         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7783         { } /* end */
7784 };
7785
7786 /*
7787  * 6ch mode
7788  */
7789 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7790         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7791         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7792         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7793         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7794         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7795         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7796         { } /* end */
7797 };
7798
7799 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7800         { 2, alc883_3ST_ch2_intel_init },
7801         { 4, alc883_3ST_ch4_intel_init },
7802         { 6, alc883_3ST_ch6_intel_init },
7803 };
7804
7805 /*
7806  * 2ch mode
7807  */
7808 static struct hda_verb alc889_ch2_intel_init[] = {
7809         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7810         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7811         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7812         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7813         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7814         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7815         { } /* end */
7816 };
7817
7818 /*
7819  * 6ch mode
7820  */
7821 static struct hda_verb alc889_ch6_intel_init[] = {
7822         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7823         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7824         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7825         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7826         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7827         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7828         { } /* end */
7829 };
7830
7831 /*
7832  * 8ch mode
7833  */
7834 static struct hda_verb alc889_ch8_intel_init[] = {
7835         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7836         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7837         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7838         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7839         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7840         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7841         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7842         { } /* end */
7843 };
7844
7845 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7846         { 2, alc889_ch2_intel_init },
7847         { 6, alc889_ch6_intel_init },
7848         { 8, alc889_ch8_intel_init },
7849 };
7850
7851 /*
7852  * 6ch mode
7853  */
7854 static struct hda_verb alc883_sixstack_ch6_init[] = {
7855         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7856         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7857         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7858         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7859         { } /* end */
7860 };
7861
7862 /*
7863  * 8ch mode
7864  */
7865 static struct hda_verb alc883_sixstack_ch8_init[] = {
7866         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7867         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7868         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7869         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7870         { } /* end */
7871 };
7872
7873 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7874         { 6, alc883_sixstack_ch6_init },
7875         { 8, alc883_sixstack_ch8_init },
7876 };
7877
7878
7879 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7880  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7881  */
7882 static struct snd_kcontrol_new alc882_base_mixer[] = {
7883         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7884         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7885         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7886         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7887         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7888         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7889         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7890         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7891         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7892         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7893         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7894         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7895         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7896         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7897         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7898         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7899         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7900         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7901         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7902         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7903         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7904         { } /* end */
7905 };
7906
7907 /* Macbook Air 2,1 same control for HP and internal Speaker */
7908
7909 static struct snd_kcontrol_new alc885_mba21_mixer[] = {
7910       HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7911       HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
7912      { }
7913 };
7914
7915
7916 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7917         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7918         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7919         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7920         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7921         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7922         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7923         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7924         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7925         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7926         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7927         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7928         { } /* end */
7929 };
7930
7931 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7932         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7933         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7934         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7935         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7936         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7937         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7938         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7939         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7940         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7941         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7942         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7943         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7944         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7945         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7946         { } /* end */
7947 };
7948
7949 static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
7950         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7951         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7952         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7953         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7954         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7955         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7956         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7957         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7958         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7959         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7960         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7961         { } /* end */
7962 };
7963
7964 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7965         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7966         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7967         { } /* end */
7968 };
7969
7970
7971 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7972         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7973         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7974         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7975         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7976         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7977         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7978         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7979         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7980         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7981         { } /* end */
7982 };
7983
7984 static struct snd_kcontrol_new alc882_targa_mixer[] = {
7985         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7986         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7987         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7988         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7989         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7990         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7991         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7992         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7993         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7994         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7995         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7996         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7997         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7998         { } /* end */
7999 };
8000
8001 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
8002  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
8003  */
8004 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
8005         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8006         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8007         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8008         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
8009         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8010         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8011         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8012         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8013         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
8014         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
8015         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8016         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8017         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8018         { } /* end */
8019 };
8020
8021 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
8022         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8023         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8024         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8025         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8026         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8027         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8028         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8029         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8030         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8031         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8032         { } /* end */
8033 };
8034
8035 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
8036         {
8037                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8038                 .name = "Channel Mode",
8039                 .info = alc_ch_mode_info,
8040                 .get = alc_ch_mode_get,
8041                 .put = alc_ch_mode_put,
8042         },
8043         { } /* end */
8044 };
8045
8046 static struct hda_verb alc882_base_init_verbs[] = {
8047         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8048         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8049         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8050         /* Rear mixer */
8051         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8052         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8053         /* CLFE mixer */
8054         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8055         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8056         /* Side mixer */
8057         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8058         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8059
8060         /* Front Pin: output 0 (0x0c) */
8061         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8062         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8063         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8064         /* Rear Pin: output 1 (0x0d) */
8065         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8066         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8067         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8068         /* CLFE Pin: output 2 (0x0e) */
8069         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8070         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8071         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8072         /* Side Pin: output 3 (0x0f) */
8073         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8074         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8075         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8076         /* Mic (rear) pin: input vref at 80% */
8077         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8078         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8079         /* Front Mic pin: input vref at 80% */
8080         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8081         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8082         /* Line In pin: input */
8083         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8084         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8085         /* Line-2 In: Headphone output (output 0 - 0x0c) */
8086         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8087         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8088         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8089         /* CD pin widget for input */
8090         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8091
8092         /* FIXME: use matrix-type input source selection */
8093         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8094         /* Input mixer2 */
8095         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8096         /* Input mixer3 */
8097         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8098         /* ADC2: mute amp left and right */
8099         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8100         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8101         /* ADC3: mute amp left and right */
8102         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8103         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8104
8105         { }
8106 };
8107
8108 static struct hda_verb alc882_adc1_init_verbs[] = {
8109         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8110         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8111         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8112         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8113         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8114         /* ADC1: mute amp left and right */
8115         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8116         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8117         { }
8118 };
8119
8120 static struct hda_verb alc882_eapd_verbs[] = {
8121         /* change to EAPD mode */
8122         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8123         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
8124         { }
8125 };
8126
8127 static struct hda_verb alc889_eapd_verbs[] = {
8128         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
8129         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
8130         { }
8131 };
8132
8133 static struct hda_verb alc_hp15_unsol_verbs[] = {
8134         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8135         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8136         {}
8137 };
8138
8139 static struct hda_verb alc885_init_verbs[] = {
8140         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8141         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8142         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8143         /* Rear mixer */
8144         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8145         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8146         /* CLFE mixer */
8147         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8148         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8149         /* Side mixer */
8150         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8151         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8152
8153         /* Front HP Pin: output 0 (0x0c) */
8154         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8155         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8156         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8157         /* Front Pin: output 0 (0x0c) */
8158         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8159         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8160         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8161         /* Rear Pin: output 1 (0x0d) */
8162         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8163         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8164         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
8165         /* CLFE Pin: output 2 (0x0e) */
8166         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8167         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8168         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8169         /* Side Pin: output 3 (0x0f) */
8170         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8171         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8172         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8173         /* Mic (rear) pin: input vref at 80% */
8174         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8175         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8176         /* Front Mic pin: input vref at 80% */
8177         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8178         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8179         /* Line In pin: input */
8180         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8181         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8182
8183         /* Mixer elements: 0x18, , 0x1a, 0x1b */
8184         /* Input mixer1 */
8185         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8186         /* Input mixer2 */
8187         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8188         /* Input mixer3 */
8189         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8190         /* ADC2: mute amp left and right */
8191         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8192         /* ADC3: mute amp left and right */
8193         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8194
8195         { }
8196 };
8197
8198 static struct hda_verb alc885_init_input_verbs[] = {
8199         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8200         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8201         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
8202         { }
8203 };
8204
8205
8206 /* Unmute Selector 24h and set the default input to front mic */
8207 static struct hda_verb alc889_init_input_verbs[] = {
8208         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
8209         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8210         { }
8211 };
8212
8213
8214 #define alc883_init_verbs       alc882_base_init_verbs
8215
8216 /* Mac Pro test */
8217 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
8218         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8219         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8220         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
8221         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8222         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8223         /* FIXME: this looks suspicious...
8224         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
8225         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
8226         */
8227         { } /* end */
8228 };
8229
8230 static struct hda_verb alc882_macpro_init_verbs[] = {
8231         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8232         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8233         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8234         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8235         /* Front Pin: output 0 (0x0c) */
8236         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8237         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8238         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8239         /* Front Mic pin: input vref at 80% */
8240         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8241         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8242         /* Speaker:  output */
8243         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8244         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8245         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
8246         /* Headphone output (output 0 - 0x0c) */
8247         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8248         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8249         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8250
8251         /* FIXME: use matrix-type input source selection */
8252         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8253         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8254         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8255         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8256         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8257         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8258         /* Input mixer2 */
8259         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8260         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8261         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8262         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8263         /* Input mixer3 */
8264         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8265         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8266         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8267         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8268         /* ADC1: mute amp left and right */
8269         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8270         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8271         /* ADC2: mute amp left and right */
8272         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8273         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8274         /* ADC3: mute amp left and right */
8275         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8276         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8277
8278         { }
8279 };
8280
8281 /* Macbook 5,1 */
8282 static struct hda_verb alc885_mb5_init_verbs[] = {
8283         /* DACs */
8284         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8285         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8286         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8287         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8288         /* Front mixer */
8289         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8290         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8291         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8292         /* Surround mixer */
8293         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8294         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8295         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8296         /* LFE mixer */
8297         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8298         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8299         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8300         /* HP mixer */
8301         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8302         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8303         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8304         /* Front Pin (0x0c) */
8305         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8306         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8307         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8308         /* LFE Pin (0x0e) */
8309         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8310         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8311         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8312         /* HP Pin (0x0f) */
8313         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8314         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8315         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8316         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8317         /* Front Mic pin: input vref at 80% */
8318         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8319         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8320         /* Line In pin */
8321         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8322         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8323
8324         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)},
8325         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)},
8326         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)},
8327         { }
8328 };
8329
8330 /* Macmini 3,1 */
8331 static struct hda_verb alc885_macmini3_init_verbs[] = {
8332         /* DACs */
8333         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8334         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8335         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8336         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8337         /* Front mixer */
8338         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8339         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8340         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8341         /* Surround mixer */
8342         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8343         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8344         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8345         /* LFE mixer */
8346         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8347         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8348         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8349         /* HP mixer */
8350         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8351         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8352         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8353         /* Front Pin (0x0c) */
8354         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8355         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8356         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8357         /* LFE Pin (0x0e) */
8358         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8359         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8360         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8361         /* HP Pin (0x0f) */
8362         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8363         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8364         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8365         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8366         /* Line In pin */
8367         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8368         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8369
8370         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8371         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8372         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8373         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8374         { }
8375 };
8376
8377
8378 static struct hda_verb alc885_mba21_init_verbs[] = {
8379         /*Internal and HP Speaker Mixer*/
8380         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8381         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8382         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8383         /*Internal Speaker Pin (0x0c)*/
8384         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8385         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8386         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8387         /* HP Pin: output 0 (0x0e) */
8388         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8389         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8390         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8391         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8392         /* Line in (is hp when jack connected)*/
8393         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8394         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8395
8396         { }
8397  };
8398
8399
8400 /* Macbook Pro rev3 */
8401 static struct hda_verb alc885_mbp3_init_verbs[] = {
8402         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8403         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8404         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8405         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8406         /* Rear mixer */
8407         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8408         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8409         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8410         /* HP mixer */
8411         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8412         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8413         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8414         /* Front Pin: output 0 (0x0c) */
8415         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8416         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8417         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8418         /* HP Pin: output 0 (0x0e) */
8419         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8420         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8421         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
8422         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8423         /* Mic (rear) pin: input vref at 80% */
8424         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8425         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8426         /* Front Mic pin: input vref at 80% */
8427         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8428         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8429         /* Line In pin: use output 1 when in LineOut mode */
8430         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8431         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8432         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8433
8434         /* FIXME: use matrix-type input source selection */
8435         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8436         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8437         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8438         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8439         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8440         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8441         /* Input mixer2 */
8442         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8443         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8444         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8445         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8446         /* Input mixer3 */
8447         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8448         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8449         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8450         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8451         /* ADC1: mute amp left and right */
8452         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8453         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8454         /* ADC2: mute amp left and right */
8455         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8456         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8457         /* ADC3: mute amp left and right */
8458         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8459         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8460
8461         { }
8462 };
8463
8464 /* iMac 9,1 */
8465 static struct hda_verb alc885_imac91_init_verbs[] = {
8466         /* Internal Speaker Pin (0x0c) */
8467         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8468         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8469         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8470         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8471         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8472         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8473         /* HP Pin: Rear */
8474         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8475         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8476         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8477         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8478         /* Line in Rear */
8479         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8480         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8481         /* Front Mic pin: input vref at 80% */
8482         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8483         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8484         /* Rear mixer */
8485         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8486         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8487         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8488         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
8489         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8490         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8491         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8492         /* 0x24 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8493         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8494         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8495         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8496         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8497         /* 0x23 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8498         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8499         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8500         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8501         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8502         /* 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8503         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8504         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8505         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8506         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8507         /* 0x07 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8508         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8509         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8510         /* 0x08 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8511         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8512         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8513         /* 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8514         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8515         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8516         { }
8517 };
8518
8519 /* iMac 24 mixer. */
8520 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
8521         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8522         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
8523         { } /* end */
8524 };
8525
8526 /* iMac 24 init verbs. */
8527 static struct hda_verb alc885_imac24_init_verbs[] = {
8528         /* Internal speakers: output 0 (0x0c) */
8529         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8530         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8531         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8532         /* Internal speakers: output 0 (0x0c) */
8533         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8534         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8535         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8536         /* Headphone: output 0 (0x0c) */
8537         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8538         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8539         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8540         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8541         /* Front Mic: input vref at 80% */
8542         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8543         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8544         { }
8545 };
8546
8547 /* Toggle speaker-output according to the hp-jack state */
8548 static void alc885_imac24_setup(struct hda_codec *codec)
8549 {
8550         struct alc_spec *spec = codec->spec;
8551
8552         spec->autocfg.hp_pins[0] = 0x14;
8553         spec->autocfg.speaker_pins[0] = 0x18;
8554         spec->autocfg.speaker_pins[1] = 0x1a;
8555 }
8556
8557 #define alc885_mb5_setup        alc885_imac24_setup
8558 #define alc885_macmini3_setup   alc885_imac24_setup
8559
8560 /* Macbook Air 2,1 */
8561 static void alc885_mba21_setup(struct hda_codec *codec)
8562 {
8563        struct alc_spec *spec = codec->spec;
8564
8565        spec->autocfg.hp_pins[0] = 0x14;
8566        spec->autocfg.speaker_pins[0] = 0x18;
8567 }
8568
8569
8570
8571 static void alc885_mbp3_setup(struct hda_codec *codec)
8572 {
8573         struct alc_spec *spec = codec->spec;
8574
8575         spec->autocfg.hp_pins[0] = 0x15;
8576         spec->autocfg.speaker_pins[0] = 0x14;
8577 }
8578
8579 static void alc885_imac91_setup(struct hda_codec *codec)
8580 {
8581         struct alc_spec *spec = codec->spec;
8582
8583         spec->autocfg.hp_pins[0] = 0x14;
8584         spec->autocfg.speaker_pins[0] = 0x18;
8585         spec->autocfg.speaker_pins[1] = 0x1a;
8586 }
8587
8588 static struct hda_verb alc882_targa_verbs[] = {
8589         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8590         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8591
8592         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8593         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8594
8595         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8596         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8597         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8598
8599         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8600         { } /* end */
8601 };
8602
8603 /* toggle speaker-output according to the hp-jack state */
8604 static void alc882_targa_automute(struct hda_codec *codec)
8605 {
8606         struct alc_spec *spec = codec->spec;
8607         alc_automute_amp(codec);
8608         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8609                                   spec->jack_present ? 1 : 3);
8610 }
8611
8612 static void alc882_targa_setup(struct hda_codec *codec)
8613 {
8614         struct alc_spec *spec = codec->spec;
8615
8616         spec->autocfg.hp_pins[0] = 0x14;
8617         spec->autocfg.speaker_pins[0] = 0x1b;
8618 }
8619
8620 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8621 {
8622         if ((res >> 26) == ALC880_HP_EVENT)
8623                 alc882_targa_automute(codec);
8624 }
8625
8626 static struct hda_verb alc882_asus_a7j_verbs[] = {
8627         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8628         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8629
8630         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8631         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8632         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8633
8634         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8635         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8636         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8637
8638         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8639         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8640         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8641         { } /* end */
8642 };
8643
8644 static struct hda_verb alc882_asus_a7m_verbs[] = {
8645         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8646         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8647
8648         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8649         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8650         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8651
8652         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8653         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8654         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8655
8656         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8657         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8658         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8659         { } /* end */
8660 };
8661
8662 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8663 {
8664         unsigned int gpiostate, gpiomask, gpiodir;
8665
8666         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8667                                        AC_VERB_GET_GPIO_DATA, 0);
8668
8669         if (!muted)
8670                 gpiostate |= (1 << pin);
8671         else
8672                 gpiostate &= ~(1 << pin);
8673
8674         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
8675                                       AC_VERB_GET_GPIO_MASK, 0);
8676         gpiomask |= (1 << pin);
8677
8678         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
8679                                      AC_VERB_GET_GPIO_DIRECTION, 0);
8680         gpiodir |= (1 << pin);
8681
8682
8683         snd_hda_codec_write(codec, codec->afg, 0,
8684                             AC_VERB_SET_GPIO_MASK, gpiomask);
8685         snd_hda_codec_write(codec, codec->afg, 0,
8686                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
8687
8688         msleep(1);
8689
8690         snd_hda_codec_write(codec, codec->afg, 0,
8691                             AC_VERB_SET_GPIO_DATA, gpiostate);
8692 }
8693
8694 /* set up GPIO at initialization */
8695 static void alc885_macpro_init_hook(struct hda_codec *codec)
8696 {
8697         alc882_gpio_mute(codec, 0, 0);
8698         alc882_gpio_mute(codec, 1, 0);
8699 }
8700
8701 /* set up GPIO and update auto-muting at initialization */
8702 static void alc885_imac24_init_hook(struct hda_codec *codec)
8703 {
8704         alc885_macpro_init_hook(codec);
8705         alc_automute_amp(codec);
8706 }
8707
8708 /*
8709  * generic initialization of ADC, input mixers and output mixers
8710  */
8711 static struct hda_verb alc883_auto_init_verbs[] = {
8712         /*
8713          * Unmute ADC0-2 and set the default input to mic-in
8714          */
8715         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8716         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8717         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8718         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8719
8720         /*
8721          * Set up output mixers (0x0c - 0x0f)
8722          */
8723         /* set vol=0 to output mixers */
8724         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8725         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8726         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8727         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8728         /* set up input amps for analog loopback */
8729         /* Amp Indices: DAC = 0, mixer = 1 */
8730         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8731         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8732         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8733         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8734         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8735         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8736         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8737         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8738         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8739         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8740
8741         /* FIXME: use matrix-type input source selection */
8742         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8743         /* Input mixer2 */
8744         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8745         /* Input mixer3 */
8746         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8747         { }
8748 };
8749
8750 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
8751 static struct hda_verb alc889A_mb31_ch2_init[] = {
8752         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8753         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8754         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8755         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8756         { } /* end */
8757 };
8758
8759 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
8760 static struct hda_verb alc889A_mb31_ch4_init[] = {
8761         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8762         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8763         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8764         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8765         { } /* end */
8766 };
8767
8768 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
8769 static struct hda_verb alc889A_mb31_ch5_init[] = {
8770         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
8771         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8772         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8773         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8774         { } /* end */
8775 };
8776
8777 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
8778 static struct hda_verb alc889A_mb31_ch6_init[] = {
8779         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
8780         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
8781         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8782         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8783         { } /* end */
8784 };
8785
8786 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
8787         { 2, alc889A_mb31_ch2_init },
8788         { 4, alc889A_mb31_ch4_init },
8789         { 5, alc889A_mb31_ch5_init },
8790         { 6, alc889A_mb31_ch6_init },
8791 };
8792
8793 static struct hda_verb alc883_medion_eapd_verbs[] = {
8794         /* eanable EAPD on medion laptop */
8795         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8796         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8797         { }
8798 };
8799
8800 #define alc883_base_mixer       alc882_base_mixer
8801
8802 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8803         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8804         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8805         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8806         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8807         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8808         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8809         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8810         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8811         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8812         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8813         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8814         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8815         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8816         { } /* end */
8817 };
8818
8819 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8820         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8821         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8822         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8823         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8824         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8825         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8826         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8827         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8828         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8829         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8830         { } /* end */
8831 };
8832
8833 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8834         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8835         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8836         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8837         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8838         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8839         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8840         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8841         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8842         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8843         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8844         { } /* end */
8845 };
8846
8847 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8848         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8849         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8850         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8851         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8852         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8853         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8854         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8855         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8856         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8857         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8858         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8859         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8860         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8861         { } /* end */
8862 };
8863
8864 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8865         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8866         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8867         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8868         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8869         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8870         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8871         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8872         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8873         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8874         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8875         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8876         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8877         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8878         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8879         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8880         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8881         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8882         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8883         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8884         { } /* end */
8885 };
8886
8887 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8888         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8889         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8890         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8891         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8892         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8893                               HDA_OUTPUT),
8894         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8895         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8896         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8897         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8898         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8899         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8900         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8901         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8902         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8903         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8904         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8905         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8906         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8907         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8908         { } /* end */
8909 };
8910
8911 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8912         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8913         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8914         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8915         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8916         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8917                               HDA_OUTPUT),
8918         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8919         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8920         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8921         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8922         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8923         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8924         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8925         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8926         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8927         HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
8928         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8929         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8930         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8931         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8932         { } /* end */
8933 };
8934
8935 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8936         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8937         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8938         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8939         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8940         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8941         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8942         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8943         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8944         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8945         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8946         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8947         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8948         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8949         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8950         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8951         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8952         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8953         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8954         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8955         { } /* end */
8956 };
8957
8958 static struct snd_kcontrol_new alc883_targa_mixer[] = {
8959         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8960         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8961         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8962         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8963         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8964         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8965         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8966         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8967         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8968         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8969         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8970         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8971         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8972         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8973         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8974         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8975         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8976         { } /* end */
8977 };
8978
8979 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
8980         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8981         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8982         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8983         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8984         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8985         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8986         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8987         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8988         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8989         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8990         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8991         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8992         { } /* end */
8993 };
8994
8995 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
8996         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8997         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8998         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8999         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9000         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9001         { } /* end */
9002 };
9003
9004 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
9005         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9006         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9007         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9008         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9009         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9010         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9011         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9012         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9013         { } /* end */
9014 };
9015
9016 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
9017         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9018         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
9019         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9020         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9021         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9022         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9023         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9024         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9025         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9026         { } /* end */
9027 };
9028
9029 static struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
9030         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9031         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9032         HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9033         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
9034         HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
9035         HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
9036         { } /* end */
9037 };
9038
9039 static struct hda_verb alc883_medion_wim2160_verbs[] = {
9040         /* Unmute front mixer */
9041         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9042         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9043
9044         /* Set speaker pin to front mixer */
9045         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9046
9047         /* Init headphone pin */
9048         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9049         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9050         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9051         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9052
9053         { } /* end */
9054 };
9055
9056 /* toggle speaker-output according to the hp-jack state */
9057 static void alc883_medion_wim2160_setup(struct hda_codec *codec)
9058 {
9059         struct alc_spec *spec = codec->spec;
9060
9061         spec->autocfg.hp_pins[0] = 0x1a;
9062         spec->autocfg.speaker_pins[0] = 0x15;
9063 }
9064
9065 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
9066         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9067         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9068         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
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", 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 alc888_acer_aspire_6530_mixer[] = {
9078         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9079         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9080         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9081         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
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", 0x18, 0, HDA_INPUT),
9086         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9087         { } /* end */
9088 };
9089
9090 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
9091         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9092         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9093         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9094         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
9095         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
9096                                                 0x0d, 1, 0x0, HDA_OUTPUT),
9097         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
9098         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
9099         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
9100         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9101         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9102         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9103         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9104         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9105         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9106         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9107         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9108         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9109         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9110         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9111         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9112         { } /* end */
9113 };
9114
9115 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
9116         /* Output mixers */
9117         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
9118         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
9119         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
9120         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
9121         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
9122                 HDA_OUTPUT),
9123         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
9124         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
9125         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
9126         /* Output switches */
9127         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
9128         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
9129         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
9130         /* Boost mixers */
9131         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
9132         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
9133         /* Input mixers */
9134         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
9135         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
9136         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9137         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9138         { } /* end */
9139 };
9140
9141 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
9142         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9143         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9144         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9145         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9146         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
9147         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9148         { } /* end */
9149 };
9150
9151 static struct hda_bind_ctls alc883_bind_cap_vol = {
9152         .ops = &snd_hda_bind_vol,
9153         .values = {
9154                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9155                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9156                 0
9157         },
9158 };
9159
9160 static struct hda_bind_ctls alc883_bind_cap_switch = {
9161         .ops = &snd_hda_bind_sw,
9162         .values = {
9163                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9164                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9165                 0
9166         },
9167 };
9168
9169 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
9170         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9171         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9172         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9173         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9174         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9175         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9176         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9177         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9178         { } /* end */
9179 };
9180
9181 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
9182         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
9183         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
9184         {
9185                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9186                 /* .name = "Capture Source", */
9187                 .name = "Input Source",
9188                 .count = 1,
9189                 .info = alc_mux_enum_info,
9190                 .get = alc_mux_enum_get,
9191                 .put = alc_mux_enum_put,
9192         },
9193         { } /* end */
9194 };
9195
9196 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
9197         {
9198                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9199                 .name = "Channel Mode",
9200                 .info = alc_ch_mode_info,
9201                 .get = alc_ch_mode_get,
9202                 .put = alc_ch_mode_put,
9203         },
9204         { } /* end */
9205 };
9206
9207 /* toggle speaker-output according to the hp-jack state */
9208 static void alc883_mitac_setup(struct hda_codec *codec)
9209 {
9210         struct alc_spec *spec = codec->spec;
9211
9212         spec->autocfg.hp_pins[0] = 0x15;
9213         spec->autocfg.speaker_pins[0] = 0x14;
9214         spec->autocfg.speaker_pins[1] = 0x17;
9215 }
9216
9217 /* auto-toggle front mic */
9218 /*
9219 static void alc883_mitac_mic_automute(struct hda_codec *codec)
9220 {
9221         unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0;
9222
9223         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
9224 }
9225 */
9226
9227 static struct hda_verb alc883_mitac_verbs[] = {
9228         /* HP */
9229         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9230         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9231         /* Subwoofer */
9232         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9233         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9234
9235         /* enable unsolicited event */
9236         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9237         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
9238
9239         { } /* end */
9240 };
9241
9242 static struct hda_verb alc883_clevo_m540r_verbs[] = {
9243         /* HP */
9244         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9245         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9246         /* Int speaker */
9247         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
9248
9249         /* enable unsolicited event */
9250         /*
9251         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9252         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9253         */
9254
9255         { } /* end */
9256 };
9257
9258 static struct hda_verb alc883_clevo_m720_verbs[] = {
9259         /* HP */
9260         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9261         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9262         /* Int speaker */
9263         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
9264         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9265
9266         /* enable unsolicited event */
9267         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9268         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9269
9270         { } /* end */
9271 };
9272
9273 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
9274         /* HP */
9275         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9276         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9277         /* Subwoofer */
9278         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9279         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9280
9281         /* enable unsolicited event */
9282         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9283
9284         { } /* end */
9285 };
9286
9287 static struct hda_verb alc883_targa_verbs[] = {
9288         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9289         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9290
9291         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9292         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9293
9294 /* Connect Line-Out side jack (SPDIF) to Side */
9295         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9296         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9297         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
9298 /* Connect Mic jack to CLFE */
9299         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9300         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9301         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
9302 /* Connect Line-in jack to Surround */
9303         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9304         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9305         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
9306 /* Connect HP out jack to Front */
9307         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9308         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9309         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9310
9311         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9312
9313         { } /* end */
9314 };
9315
9316 static struct hda_verb alc883_lenovo_101e_verbs[] = {
9317         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9318         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
9319         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
9320         { } /* end */
9321 };
9322
9323 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
9324         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9325         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9326         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9327         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9328         { } /* end */
9329 };
9330
9331 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
9332         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9333         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9334         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9335         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
9336         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
9337         { } /* end */
9338 };
9339
9340 static struct hda_verb alc883_haier_w66_verbs[] = {
9341         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9342         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9343
9344         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9345
9346         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9347         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9348         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9349         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9350         { } /* end */
9351 };
9352
9353 static struct hda_verb alc888_lenovo_sky_verbs[] = {
9354         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9355         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9356         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9357         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9358         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9359         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9360         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9361         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9362         { } /* end */
9363 };
9364
9365 static struct hda_verb alc888_6st_dell_verbs[] = {
9366         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9367         { }
9368 };
9369
9370 static struct hda_verb alc883_vaiott_verbs[] = {
9371         /* HP */
9372         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9373         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9374
9375         /* enable unsolicited event */
9376         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9377
9378         { } /* end */
9379 };
9380
9381 static void alc888_3st_hp_setup(struct hda_codec *codec)
9382 {
9383         struct alc_spec *spec = codec->spec;
9384
9385         spec->autocfg.hp_pins[0] = 0x1b;
9386         spec->autocfg.speaker_pins[0] = 0x14;
9387         spec->autocfg.speaker_pins[1] = 0x16;
9388         spec->autocfg.speaker_pins[2] = 0x18;
9389 }
9390
9391 static struct hda_verb alc888_3st_hp_verbs[] = {
9392         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
9393         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
9394         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
9395         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9396         { } /* end */
9397 };
9398
9399 /*
9400  * 2ch mode
9401  */
9402 static struct hda_verb alc888_3st_hp_2ch_init[] = {
9403         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9404         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9405         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
9406         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9407         { } /* end */
9408 };
9409
9410 /*
9411  * 4ch mode
9412  */
9413 static struct hda_verb alc888_3st_hp_4ch_init[] = {
9414         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9415         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9416         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9417         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9418         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9419         { } /* end */
9420 };
9421
9422 /*
9423  * 6ch mode
9424  */
9425 static struct hda_verb alc888_3st_hp_6ch_init[] = {
9426         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9427         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9428         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
9429         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9430         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9431         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9432         { } /* end */
9433 };
9434
9435 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
9436         { 2, alc888_3st_hp_2ch_init },
9437         { 4, alc888_3st_hp_4ch_init },
9438         { 6, alc888_3st_hp_6ch_init },
9439 };
9440
9441 /* toggle front-jack and RCA according to the hp-jack state */
9442 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
9443 {
9444         unsigned int present = snd_hda_jack_detect(codec, 0x1b);
9445
9446         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9447                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9448         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9449                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9450 }
9451
9452 /* toggle RCA according to the front-jack state */
9453 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
9454 {
9455         unsigned int present = snd_hda_jack_detect(codec, 0x14);
9456
9457         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9458                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9459 }
9460
9461 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
9462                                              unsigned int res)
9463 {
9464         if ((res >> 26) == ALC880_HP_EVENT)
9465                 alc888_lenovo_ms7195_front_automute(codec);
9466         if ((res >> 26) == ALC880_FRONT_EVENT)
9467                 alc888_lenovo_ms7195_rca_automute(codec);
9468 }
9469
9470 /* toggle speaker-output according to the hp-jack state */
9471 static void alc883_lenovo_nb0763_setup(struct hda_codec *codec)
9472 {
9473         struct alc_spec *spec = codec->spec;
9474
9475         spec->autocfg.hp_pins[0] = 0x14;
9476         spec->autocfg.speaker_pins[0] = 0x15;
9477 }
9478
9479 /* toggle speaker-output according to the hp-jack state */
9480 #define alc883_targa_init_hook          alc882_targa_init_hook
9481 #define alc883_targa_unsol_event        alc882_targa_unsol_event
9482
9483 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
9484 {
9485         unsigned int present;
9486
9487         present = snd_hda_jack_detect(codec, 0x18);
9488         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
9489                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9490 }
9491
9492 static void alc883_clevo_m720_setup(struct hda_codec *codec)
9493 {
9494         struct alc_spec *spec = codec->spec;
9495
9496         spec->autocfg.hp_pins[0] = 0x15;
9497         spec->autocfg.speaker_pins[0] = 0x14;
9498 }
9499
9500 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
9501 {
9502         alc_automute_amp(codec);
9503         alc883_clevo_m720_mic_automute(codec);
9504 }
9505
9506 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
9507                                            unsigned int res)
9508 {
9509         switch (res >> 26) {
9510         case ALC880_MIC_EVENT:
9511                 alc883_clevo_m720_mic_automute(codec);
9512                 break;
9513         default:
9514                 alc_automute_amp_unsol_event(codec, res);
9515                 break;
9516         }
9517 }
9518
9519 /* toggle speaker-output according to the hp-jack state */
9520 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
9521 {
9522         struct alc_spec *spec = codec->spec;
9523
9524         spec->autocfg.hp_pins[0] = 0x14;
9525         spec->autocfg.speaker_pins[0] = 0x15;
9526 }
9527
9528 static void alc883_haier_w66_setup(struct hda_codec *codec)
9529 {
9530         struct alc_spec *spec = codec->spec;
9531
9532         spec->autocfg.hp_pins[0] = 0x1b;
9533         spec->autocfg.speaker_pins[0] = 0x14;
9534 }
9535
9536 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
9537 {
9538         int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
9539
9540         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9541                                  HDA_AMP_MUTE, bits);
9542 }
9543
9544 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
9545 {
9546         int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
9547
9548         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9549                                  HDA_AMP_MUTE, bits);
9550         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9551                                  HDA_AMP_MUTE, bits);
9552 }
9553
9554 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
9555                                            unsigned int res)
9556 {
9557         if ((res >> 26) == ALC880_HP_EVENT)
9558                 alc883_lenovo_101e_all_automute(codec);
9559         if ((res >> 26) == ALC880_FRONT_EVENT)
9560                 alc883_lenovo_101e_ispeaker_automute(codec);
9561 }
9562
9563 /* toggle speaker-output according to the hp-jack state */
9564 static void alc883_acer_aspire_setup(struct hda_codec *codec)
9565 {
9566         struct alc_spec *spec = codec->spec;
9567
9568         spec->autocfg.hp_pins[0] = 0x14;
9569         spec->autocfg.speaker_pins[0] = 0x15;
9570         spec->autocfg.speaker_pins[1] = 0x16;
9571 }
9572
9573 static struct hda_verb alc883_acer_eapd_verbs[] = {
9574         /* HP Pin: output 0 (0x0c) */
9575         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9576         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9577         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9578         /* Front Pin: output 0 (0x0c) */
9579         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9580         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9581         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9582         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
9583         /* eanable EAPD on medion laptop */
9584         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9585         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9586         /* enable unsolicited event */
9587         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9588         { }
9589 };
9590
9591 static void alc888_6st_dell_setup(struct hda_codec *codec)
9592 {
9593         struct alc_spec *spec = codec->spec;
9594
9595         spec->autocfg.hp_pins[0] = 0x1b;
9596         spec->autocfg.speaker_pins[0] = 0x14;
9597         spec->autocfg.speaker_pins[1] = 0x15;
9598         spec->autocfg.speaker_pins[2] = 0x16;
9599         spec->autocfg.speaker_pins[3] = 0x17;
9600 }
9601
9602 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9603 {
9604         struct alc_spec *spec = codec->spec;
9605
9606         spec->autocfg.hp_pins[0] = 0x1b;
9607         spec->autocfg.speaker_pins[0] = 0x14;
9608         spec->autocfg.speaker_pins[1] = 0x15;
9609         spec->autocfg.speaker_pins[2] = 0x16;
9610         spec->autocfg.speaker_pins[3] = 0x17;
9611         spec->autocfg.speaker_pins[4] = 0x1a;
9612 }
9613
9614 static void alc883_vaiott_setup(struct hda_codec *codec)
9615 {
9616         struct alc_spec *spec = codec->spec;
9617
9618         spec->autocfg.hp_pins[0] = 0x15;
9619         spec->autocfg.speaker_pins[0] = 0x14;
9620         spec->autocfg.speaker_pins[1] = 0x17;
9621 }
9622
9623 static struct hda_verb alc888_asus_m90v_verbs[] = {
9624         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9625         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9626         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9627         /* enable unsolicited event */
9628         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9629         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9630         { } /* end */
9631 };
9632
9633 static void alc883_mode2_setup(struct hda_codec *codec)
9634 {
9635         struct alc_spec *spec = codec->spec;
9636
9637         spec->autocfg.hp_pins[0] = 0x1b;
9638         spec->autocfg.speaker_pins[0] = 0x14;
9639         spec->autocfg.speaker_pins[1] = 0x15;
9640         spec->autocfg.speaker_pins[2] = 0x16;
9641         spec->ext_mic.pin = 0x18;
9642         spec->int_mic.pin = 0x19;
9643         spec->ext_mic.mux_idx = 0;
9644         spec->int_mic.mux_idx = 1;
9645         spec->auto_mic = 1;
9646 }
9647
9648 static struct hda_verb alc888_asus_eee1601_verbs[] = {
9649         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9650         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9651         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9652         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9653         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9654         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9655         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9656         /* enable unsolicited event */
9657         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9658         { } /* end */
9659 };
9660
9661 static void alc883_eee1601_inithook(struct hda_codec *codec)
9662 {
9663         struct alc_spec *spec = codec->spec;
9664
9665         spec->autocfg.hp_pins[0] = 0x14;
9666         spec->autocfg.speaker_pins[0] = 0x1b;
9667         alc_automute_pin(codec);
9668 }
9669
9670 static struct hda_verb alc889A_mb31_verbs[] = {
9671         /* Init rear pin (used as headphone output) */
9672         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9673         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9674         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9675         /* Init line pin (used as output in 4ch and 6ch mode) */
9676         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9677         /* Init line 2 pin (used as headphone out by default) */
9678         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9679         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9680         { } /* end */
9681 };
9682
9683 /* Mute speakers according to the headphone jack state */
9684 static void alc889A_mb31_automute(struct hda_codec *codec)
9685 {
9686         unsigned int present;
9687
9688         /* Mute only in 2ch or 4ch mode */
9689         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9690             == 0x00) {
9691                 present = snd_hda_jack_detect(codec, 0x15);
9692                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9693                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9694                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9695                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9696         }
9697 }
9698
9699 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
9700 {
9701         if ((res >> 26) == ALC880_HP_EVENT)
9702                 alc889A_mb31_automute(codec);
9703 }
9704
9705
9706 #ifdef CONFIG_SND_HDA_POWER_SAVE
9707 #define alc882_loopbacks        alc880_loopbacks
9708 #endif
9709
9710 /* pcm configuration: identical with ALC880 */
9711 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
9712 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
9713 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
9714 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
9715
9716 static hda_nid_t alc883_slave_dig_outs[] = {
9717         ALC1200_DIGOUT_NID, 0,
9718 };
9719
9720 static hda_nid_t alc1200_slave_dig_outs[] = {
9721         ALC883_DIGOUT_NID, 0,
9722 };
9723
9724 /*
9725  * configuration and preset
9726  */
9727 static const char *alc882_models[ALC882_MODEL_LAST] = {
9728         [ALC882_3ST_DIG]        = "3stack-dig",
9729         [ALC882_6ST_DIG]        = "6stack-dig",
9730         [ALC882_ARIMA]          = "arima",
9731         [ALC882_W2JC]           = "w2jc",
9732         [ALC882_TARGA]          = "targa",
9733         [ALC882_ASUS_A7J]       = "asus-a7j",
9734         [ALC882_ASUS_A7M]       = "asus-a7m",
9735         [ALC885_MACPRO]         = "macpro",
9736         [ALC885_MB5]            = "mb5",
9737         [ALC885_MACMINI3]       = "macmini3",
9738         [ALC885_MBA21]          = "mba21",
9739         [ALC885_MBP3]           = "mbp3",
9740         [ALC885_IMAC24]         = "imac24",
9741         [ALC885_IMAC91]         = "imac91",
9742         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
9743         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
9744         [ALC883_3ST_6ch]        = "3stack-6ch",
9745         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
9746         [ALC883_TARGA_DIG]      = "targa-dig",
9747         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
9748         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
9749         [ALC883_ACER]           = "acer",
9750         [ALC883_ACER_ASPIRE]    = "acer-aspire",
9751         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
9752         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
9753         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
9754         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
9755         [ALC883_MEDION]         = "medion",
9756         [ALC883_MEDION_WIM2160] = "medion-wim2160",
9757         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
9758         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
9759         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
9760         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
9761         [ALC888_LENOVO_SKY] = "lenovo-sky",
9762         [ALC883_HAIER_W66]      = "haier-w66",
9763         [ALC888_3ST_HP]         = "3stack-hp",
9764         [ALC888_6ST_DELL]       = "6stack-dell",
9765         [ALC883_MITAC]          = "mitac",
9766         [ALC883_CLEVO_M540R]    = "clevo-m540r",
9767         [ALC883_CLEVO_M720]     = "clevo-m720",
9768         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
9769         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
9770         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
9771         [ALC889A_INTEL]         = "intel-alc889a",
9772         [ALC889_INTEL]          = "intel-x58",
9773         [ALC1200_ASUS_P5Q]      = "asus-p5q",
9774         [ALC889A_MB31]          = "mb31",
9775         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
9776         [ALC882_AUTO]           = "auto",
9777 };
9778
9779 static struct snd_pci_quirk alc882_cfg_tbl[] = {
9780         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
9781
9782         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
9783         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
9784         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
9785         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
9786         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
9787         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
9788         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
9789                 ALC888_ACER_ASPIRE_4930G),
9790         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
9791                 ALC888_ACER_ASPIRE_4930G),
9792         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
9793                 ALC888_ACER_ASPIRE_8930G),
9794         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
9795                 ALC888_ACER_ASPIRE_8930G),
9796         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
9797         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9798         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9799                 ALC888_ACER_ASPIRE_6530G),
9800         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9801                 ALC888_ACER_ASPIRE_6530G),
9802         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9803                 ALC888_ACER_ASPIRE_7730G),
9804         /* default Acer -- disabled as it causes more problems.
9805          *    model=auto should work fine now
9806          */
9807         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9808
9809         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9810
9811         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9812         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9813         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9814         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9815         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9816         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9817
9818         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9819         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9820         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9821         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9822         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9823         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9824         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9825         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9826         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9827         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9828         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9829
9830         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9831         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9832         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9833         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9834         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9835         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9836         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9837         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9838         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9839
9840         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9841         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9842         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9843         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9844         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9845         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9846         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9847         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9848         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9849         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9850         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9851         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9852         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9853         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9854         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9855         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9856         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9857         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9858         SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
9859         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9860         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9861         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9862         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9863         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9864         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9865         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9866         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9867         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9868         SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
9869         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9870         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9871
9872         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9873         SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG),
9874         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9875         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9876         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9877         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9878         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9879         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9880         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9881         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9882                       ALC883_FUJITSU_PI2515),
9883         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9884                 ALC888_FUJITSU_XA3530),
9885         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9886         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9887         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9888         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9889         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9890         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9891         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9892         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9893
9894         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9895         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9896         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9897         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9898         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9899         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9900         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
9901
9902         {}
9903 };
9904
9905 /* codec SSID table for Intel Mac */
9906 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9907         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9908         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9909         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9910         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9911         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9912         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9913         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9914         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31),
9915         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M),
9916         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3),
9917         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21),
9918         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9919         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9920         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9921         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9922         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9923         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5),
9924         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9925          * so apparently no perfect solution yet
9926          */
9927         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9928         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9929         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
9930         {} /* terminator */
9931 };
9932
9933 static struct alc_config_preset alc882_presets[] = {
9934         [ALC882_3ST_DIG] = {
9935                 .mixers = { alc882_base_mixer },
9936                 .init_verbs = { alc882_base_init_verbs,
9937                                 alc882_adc1_init_verbs },
9938                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9939                 .dac_nids = alc882_dac_nids,
9940                 .dig_out_nid = ALC882_DIGOUT_NID,
9941                 .dig_in_nid = ALC882_DIGIN_NID,
9942                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9943                 .channel_mode = alc882_ch_modes,
9944                 .need_dac_fix = 1,
9945                 .input_mux = &alc882_capture_source,
9946         },
9947         [ALC882_6ST_DIG] = {
9948                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9949                 .init_verbs = { alc882_base_init_verbs,
9950                                 alc882_adc1_init_verbs },
9951                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9952                 .dac_nids = alc882_dac_nids,
9953                 .dig_out_nid = ALC882_DIGOUT_NID,
9954                 .dig_in_nid = ALC882_DIGIN_NID,
9955                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9956                 .channel_mode = alc882_sixstack_modes,
9957                 .input_mux = &alc882_capture_source,
9958         },
9959         [ALC882_ARIMA] = {
9960                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9961                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9962                                 alc882_eapd_verbs },
9963                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9964                 .dac_nids = alc882_dac_nids,
9965                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9966                 .channel_mode = alc882_sixstack_modes,
9967                 .input_mux = &alc882_capture_source,
9968         },
9969         [ALC882_W2JC] = {
9970                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9971                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9972                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
9973                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9974                 .dac_nids = alc882_dac_nids,
9975                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9976                 .channel_mode = alc880_threestack_modes,
9977                 .need_dac_fix = 1,
9978                 .input_mux = &alc882_capture_source,
9979                 .dig_out_nid = ALC882_DIGOUT_NID,
9980         },
9981            [ALC885_MBA21] = {
9982                         .mixers = { alc885_mba21_mixer },
9983                         .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
9984                         .num_dacs = 2,
9985                         .dac_nids = alc882_dac_nids,
9986                         .channel_mode = alc885_mba21_ch_modes,
9987                         .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
9988                         .input_mux = &alc882_capture_source,
9989                         .unsol_event = alc_automute_amp_unsol_event,
9990                         .setup = alc885_mba21_setup,
9991                         .init_hook = alc_automute_amp,
9992        },
9993         [ALC885_MBP3] = {
9994                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9995                 .init_verbs = { alc885_mbp3_init_verbs,
9996                                 alc880_gpio1_init_verbs },
9997                 .num_dacs = 2,
9998                 .dac_nids = alc882_dac_nids,
9999                 .hp_nid = 0x04,
10000                 .channel_mode = alc885_mbp_4ch_modes,
10001                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
10002                 .input_mux = &alc882_capture_source,
10003                 .dig_out_nid = ALC882_DIGOUT_NID,
10004                 .dig_in_nid = ALC882_DIGIN_NID,
10005                 .unsol_event = alc_automute_amp_unsol_event,
10006                 .setup = alc885_mbp3_setup,
10007                 .init_hook = alc_automute_amp,
10008         },
10009         [ALC885_MB5] = {
10010                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
10011                 .init_verbs = { alc885_mb5_init_verbs,
10012                                 alc880_gpio1_init_verbs },
10013                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10014                 .dac_nids = alc882_dac_nids,
10015                 .channel_mode = alc885_mb5_6ch_modes,
10016                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
10017                 .input_mux = &mb5_capture_source,
10018                 .dig_out_nid = ALC882_DIGOUT_NID,
10019                 .dig_in_nid = ALC882_DIGIN_NID,
10020                 .unsol_event = alc_automute_amp_unsol_event,
10021                 .setup = alc885_mb5_setup,
10022                 .init_hook = alc_automute_amp,
10023         },
10024         [ALC885_MACMINI3] = {
10025                 .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
10026                 .init_verbs = { alc885_macmini3_init_verbs,
10027                                 alc880_gpio1_init_verbs },
10028                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10029                 .dac_nids = alc882_dac_nids,
10030                 .channel_mode = alc885_macmini3_6ch_modes,
10031                 .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
10032                 .input_mux = &macmini3_capture_source,
10033                 .dig_out_nid = ALC882_DIGOUT_NID,
10034                 .dig_in_nid = ALC882_DIGIN_NID,
10035                 .unsol_event = alc_automute_amp_unsol_event,
10036                 .setup = alc885_macmini3_setup,
10037                 .init_hook = alc_automute_amp,
10038         },
10039         [ALC885_MACPRO] = {
10040                 .mixers = { alc882_macpro_mixer },
10041                 .init_verbs = { alc882_macpro_init_verbs },
10042                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10043                 .dac_nids = alc882_dac_nids,
10044                 .dig_out_nid = ALC882_DIGOUT_NID,
10045                 .dig_in_nid = ALC882_DIGIN_NID,
10046                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10047                 .channel_mode = alc882_ch_modes,
10048                 .input_mux = &alc882_capture_source,
10049                 .init_hook = alc885_macpro_init_hook,
10050         },
10051         [ALC885_IMAC24] = {
10052                 .mixers = { alc885_imac24_mixer },
10053                 .init_verbs = { alc885_imac24_init_verbs },
10054                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10055                 .dac_nids = alc882_dac_nids,
10056                 .dig_out_nid = ALC882_DIGOUT_NID,
10057                 .dig_in_nid = ALC882_DIGIN_NID,
10058                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10059                 .channel_mode = alc882_ch_modes,
10060                 .input_mux = &alc882_capture_source,
10061                 .unsol_event = alc_automute_amp_unsol_event,
10062                 .setup = alc885_imac24_setup,
10063                 .init_hook = alc885_imac24_init_hook,
10064         },
10065         [ALC885_IMAC91] = {
10066                 .mixers = {alc885_imac91_mixer},
10067                 .init_verbs = { alc885_imac91_init_verbs,
10068                                 alc880_gpio1_init_verbs },
10069                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10070                 .dac_nids = alc882_dac_nids,
10071                 .channel_mode = alc885_mba21_ch_modes,
10072                 .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10073                 .input_mux = &alc889A_imac91_capture_source,
10074                 .dig_out_nid = ALC882_DIGOUT_NID,
10075                 .dig_in_nid = ALC882_DIGIN_NID,
10076                 .unsol_event = alc_automute_amp_unsol_event,
10077                 .setup = alc885_imac91_setup,
10078                 .init_hook = alc_automute_amp,
10079         },
10080         [ALC882_TARGA] = {
10081                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
10082                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10083                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
10084                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10085                 .dac_nids = alc882_dac_nids,
10086                 .dig_out_nid = ALC882_DIGOUT_NID,
10087                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10088                 .adc_nids = alc882_adc_nids,
10089                 .capsrc_nids = alc882_capsrc_nids,
10090                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10091                 .channel_mode = alc882_3ST_6ch_modes,
10092                 .need_dac_fix = 1,
10093                 .input_mux = &alc882_capture_source,
10094                 .unsol_event = alc882_targa_unsol_event,
10095                 .setup = alc882_targa_setup,
10096                 .init_hook = alc882_targa_automute,
10097         },
10098         [ALC882_ASUS_A7J] = {
10099                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
10100                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10101                                 alc882_asus_a7j_verbs},
10102                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10103                 .dac_nids = alc882_dac_nids,
10104                 .dig_out_nid = ALC882_DIGOUT_NID,
10105                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10106                 .adc_nids = alc882_adc_nids,
10107                 .capsrc_nids = alc882_capsrc_nids,
10108                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10109                 .channel_mode = alc882_3ST_6ch_modes,
10110                 .need_dac_fix = 1,
10111                 .input_mux = &alc882_capture_source,
10112         },
10113         [ALC882_ASUS_A7M] = {
10114                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
10115                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10116                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
10117                                 alc882_asus_a7m_verbs },
10118                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10119                 .dac_nids = alc882_dac_nids,
10120                 .dig_out_nid = ALC882_DIGOUT_NID,
10121                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10122                 .channel_mode = alc880_threestack_modes,
10123                 .need_dac_fix = 1,
10124                 .input_mux = &alc882_capture_source,
10125         },
10126         [ALC883_3ST_2ch_DIG] = {
10127                 .mixers = { alc883_3ST_2ch_mixer },
10128                 .init_verbs = { alc883_init_verbs },
10129                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10130                 .dac_nids = alc883_dac_nids,
10131                 .dig_out_nid = ALC883_DIGOUT_NID,
10132                 .dig_in_nid = ALC883_DIGIN_NID,
10133                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10134                 .channel_mode = alc883_3ST_2ch_modes,
10135                 .input_mux = &alc883_capture_source,
10136         },
10137         [ALC883_3ST_6ch_DIG] = {
10138                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10139                 .init_verbs = { alc883_init_verbs },
10140                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10141                 .dac_nids = alc883_dac_nids,
10142                 .dig_out_nid = ALC883_DIGOUT_NID,
10143                 .dig_in_nid = ALC883_DIGIN_NID,
10144                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10145                 .channel_mode = alc883_3ST_6ch_modes,
10146                 .need_dac_fix = 1,
10147                 .input_mux = &alc883_capture_source,
10148         },
10149         [ALC883_3ST_6ch] = {
10150                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10151                 .init_verbs = { alc883_init_verbs },
10152                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10153                 .dac_nids = alc883_dac_nids,
10154                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10155                 .channel_mode = alc883_3ST_6ch_modes,
10156                 .need_dac_fix = 1,
10157                 .input_mux = &alc883_capture_source,
10158         },
10159         [ALC883_3ST_6ch_INTEL] = {
10160                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
10161                 .init_verbs = { alc883_init_verbs },
10162                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10163                 .dac_nids = alc883_dac_nids,
10164                 .dig_out_nid = ALC883_DIGOUT_NID,
10165                 .dig_in_nid = ALC883_DIGIN_NID,
10166                 .slave_dig_outs = alc883_slave_dig_outs,
10167                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
10168                 .channel_mode = alc883_3ST_6ch_intel_modes,
10169                 .need_dac_fix = 1,
10170                 .input_mux = &alc883_3stack_6ch_intel,
10171         },
10172         [ALC889A_INTEL] = {
10173                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10174                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
10175                                 alc_hp15_unsol_verbs },
10176                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10177                 .dac_nids = alc883_dac_nids,
10178                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10179                 .adc_nids = alc889_adc_nids,
10180                 .dig_out_nid = ALC883_DIGOUT_NID,
10181                 .dig_in_nid = ALC883_DIGIN_NID,
10182                 .slave_dig_outs = alc883_slave_dig_outs,
10183                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10184                 .channel_mode = alc889_8ch_intel_modes,
10185                 .capsrc_nids = alc889_capsrc_nids,
10186                 .input_mux = &alc889_capture_source,
10187                 .setup = alc889_automute_setup,
10188                 .init_hook = alc_automute_amp,
10189                 .unsol_event = alc_automute_amp_unsol_event,
10190                 .need_dac_fix = 1,
10191         },
10192         [ALC889_INTEL] = {
10193                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10194                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
10195                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
10196                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10197                 .dac_nids = alc883_dac_nids,
10198                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10199                 .adc_nids = alc889_adc_nids,
10200                 .dig_out_nid = ALC883_DIGOUT_NID,
10201                 .dig_in_nid = ALC883_DIGIN_NID,
10202                 .slave_dig_outs = alc883_slave_dig_outs,
10203                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10204                 .channel_mode = alc889_8ch_intel_modes,
10205                 .capsrc_nids = alc889_capsrc_nids,
10206                 .input_mux = &alc889_capture_source,
10207                 .setup = alc889_automute_setup,
10208                 .init_hook = alc889_intel_init_hook,
10209                 .unsol_event = alc_automute_amp_unsol_event,
10210                 .need_dac_fix = 1,
10211         },
10212         [ALC883_6ST_DIG] = {
10213                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10214                 .init_verbs = { alc883_init_verbs },
10215                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10216                 .dac_nids = alc883_dac_nids,
10217                 .dig_out_nid = ALC883_DIGOUT_NID,
10218                 .dig_in_nid = ALC883_DIGIN_NID,
10219                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10220                 .channel_mode = alc883_sixstack_modes,
10221                 .input_mux = &alc883_capture_source,
10222         },
10223         [ALC883_TARGA_DIG] = {
10224                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
10225                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10226                                 alc883_targa_verbs},
10227                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10228                 .dac_nids = alc883_dac_nids,
10229                 .dig_out_nid = ALC883_DIGOUT_NID,
10230                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10231                 .channel_mode = alc883_3ST_6ch_modes,
10232                 .need_dac_fix = 1,
10233                 .input_mux = &alc883_capture_source,
10234                 .unsol_event = alc883_targa_unsol_event,
10235                 .setup = alc882_targa_setup,
10236                 .init_hook = alc882_targa_automute,
10237         },
10238         [ALC883_TARGA_2ch_DIG] = {
10239                 .mixers = { alc883_targa_2ch_mixer},
10240                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10241                                 alc883_targa_verbs},
10242                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10243                 .dac_nids = alc883_dac_nids,
10244                 .adc_nids = alc883_adc_nids_alt,
10245                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10246                 .capsrc_nids = alc883_capsrc_nids,
10247                 .dig_out_nid = ALC883_DIGOUT_NID,
10248                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10249                 .channel_mode = alc883_3ST_2ch_modes,
10250                 .input_mux = &alc883_capture_source,
10251                 .unsol_event = alc883_targa_unsol_event,
10252                 .setup = alc882_targa_setup,
10253                 .init_hook = alc882_targa_automute,
10254         },
10255         [ALC883_TARGA_8ch_DIG] = {
10256                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
10257                             alc883_chmode_mixer },
10258                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10259                                 alc883_targa_verbs },
10260                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10261                 .dac_nids = alc883_dac_nids,
10262                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10263                 .adc_nids = alc883_adc_nids_rev,
10264                 .capsrc_nids = alc883_capsrc_nids_rev,
10265                 .dig_out_nid = ALC883_DIGOUT_NID,
10266                 .dig_in_nid = ALC883_DIGIN_NID,
10267                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
10268                 .channel_mode = alc883_4ST_8ch_modes,
10269                 .need_dac_fix = 1,
10270                 .input_mux = &alc883_capture_source,
10271                 .unsol_event = alc883_targa_unsol_event,
10272                 .setup = alc882_targa_setup,
10273                 .init_hook = alc882_targa_automute,
10274         },
10275         [ALC883_ACER] = {
10276                 .mixers = { alc883_base_mixer },
10277                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
10278                  * and the headphone jack.  Turn this on and rely on the
10279                  * standard mute methods whenever the user wants to turn
10280                  * these outputs off.
10281                  */
10282                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
10283                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10284                 .dac_nids = alc883_dac_nids,
10285                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10286                 .channel_mode = alc883_3ST_2ch_modes,
10287                 .input_mux = &alc883_capture_source,
10288         },
10289         [ALC883_ACER_ASPIRE] = {
10290                 .mixers = { alc883_acer_aspire_mixer },
10291                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
10292                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10293                 .dac_nids = alc883_dac_nids,
10294                 .dig_out_nid = ALC883_DIGOUT_NID,
10295                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10296                 .channel_mode = alc883_3ST_2ch_modes,
10297                 .input_mux = &alc883_capture_source,
10298                 .unsol_event = alc_automute_amp_unsol_event,
10299                 .setup = alc883_acer_aspire_setup,
10300                 .init_hook = alc_automute_amp,
10301         },
10302         [ALC888_ACER_ASPIRE_4930G] = {
10303                 .mixers = { alc888_base_mixer,
10304                                 alc883_chmode_mixer },
10305                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10306                                 alc888_acer_aspire_4930g_verbs },
10307                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10308                 .dac_nids = alc883_dac_nids,
10309                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10310                 .adc_nids = alc883_adc_nids_rev,
10311                 .capsrc_nids = alc883_capsrc_nids_rev,
10312                 .dig_out_nid = ALC883_DIGOUT_NID,
10313                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10314                 .channel_mode = alc883_3ST_6ch_modes,
10315                 .need_dac_fix = 1,
10316                 .const_channel_count = 6,
10317                 .num_mux_defs =
10318                         ARRAY_SIZE(alc888_2_capture_sources),
10319                 .input_mux = alc888_2_capture_sources,
10320                 .unsol_event = alc_automute_amp_unsol_event,
10321                 .setup = alc888_acer_aspire_4930g_setup,
10322                 .init_hook = alc_automute_amp,
10323         },
10324         [ALC888_ACER_ASPIRE_6530G] = {
10325                 .mixers = { alc888_acer_aspire_6530_mixer },
10326                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10327                                 alc888_acer_aspire_6530g_verbs },
10328                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10329                 .dac_nids = alc883_dac_nids,
10330                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10331                 .adc_nids = alc883_adc_nids_rev,
10332                 .capsrc_nids = alc883_capsrc_nids_rev,
10333                 .dig_out_nid = ALC883_DIGOUT_NID,
10334                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10335                 .channel_mode = alc883_3ST_2ch_modes,
10336                 .num_mux_defs =
10337                         ARRAY_SIZE(alc888_2_capture_sources),
10338                 .input_mux = alc888_acer_aspire_6530_sources,
10339                 .unsol_event = alc_automute_amp_unsol_event,
10340                 .setup = alc888_acer_aspire_6530g_setup,
10341                 .init_hook = alc_automute_amp,
10342         },
10343         [ALC888_ACER_ASPIRE_8930G] = {
10344                 .mixers = { alc889_acer_aspire_8930g_mixer,
10345                                 alc883_chmode_mixer },
10346                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10347                                 alc889_acer_aspire_8930g_verbs,
10348                                 alc889_eapd_verbs},
10349                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10350                 .dac_nids = alc883_dac_nids,
10351                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10352                 .adc_nids = alc889_adc_nids,
10353                 .capsrc_nids = alc889_capsrc_nids,
10354                 .dig_out_nid = ALC883_DIGOUT_NID,
10355                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10356                 .channel_mode = alc883_3ST_6ch_modes,
10357                 .need_dac_fix = 1,
10358                 .const_channel_count = 6,
10359                 .num_mux_defs =
10360                         ARRAY_SIZE(alc889_capture_sources),
10361                 .input_mux = alc889_capture_sources,
10362                 .unsol_event = alc_automute_amp_unsol_event,
10363                 .setup = alc889_acer_aspire_8930g_setup,
10364                 .init_hook = alc_automute_amp,
10365 #ifdef CONFIG_SND_HDA_POWER_SAVE
10366                 .power_hook = alc_power_eapd,
10367 #endif
10368         },
10369         [ALC888_ACER_ASPIRE_7730G] = {
10370                 .mixers = { alc883_3ST_6ch_mixer,
10371                                 alc883_chmode_mixer },
10372                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10373                                 alc888_acer_aspire_7730G_verbs },
10374                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10375                 .dac_nids = alc883_dac_nids,
10376                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10377                 .adc_nids = alc883_adc_nids_rev,
10378                 .capsrc_nids = alc883_capsrc_nids_rev,
10379                 .dig_out_nid = ALC883_DIGOUT_NID,
10380                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10381                 .channel_mode = alc883_3ST_6ch_modes,
10382                 .need_dac_fix = 1,
10383                 .const_channel_count = 6,
10384                 .input_mux = &alc883_capture_source,
10385                 .unsol_event = alc_automute_amp_unsol_event,
10386                 .setup = alc888_acer_aspire_7730g_setup,
10387                 .init_hook = alc_automute_amp,
10388         },
10389         [ALC883_MEDION] = {
10390                 .mixers = { alc883_fivestack_mixer,
10391                             alc883_chmode_mixer },
10392                 .init_verbs = { alc883_init_verbs,
10393                                 alc883_medion_eapd_verbs },
10394                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10395                 .dac_nids = alc883_dac_nids,
10396                 .adc_nids = alc883_adc_nids_alt,
10397                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10398                 .capsrc_nids = alc883_capsrc_nids,
10399                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10400                 .channel_mode = alc883_sixstack_modes,
10401                 .input_mux = &alc883_capture_source,
10402         },
10403         [ALC883_MEDION_WIM2160] = {
10404                 .mixers = { alc883_medion_wim2160_mixer },
10405                 .init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
10406                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10407                 .dac_nids = alc883_dac_nids,
10408                 .dig_out_nid = ALC883_DIGOUT_NID,
10409                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10410                 .adc_nids = alc883_adc_nids,
10411                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10412                 .channel_mode = alc883_3ST_2ch_modes,
10413                 .input_mux = &alc883_capture_source,
10414                 .unsol_event = alc_automute_amp_unsol_event,
10415                 .setup = alc883_medion_wim2160_setup,
10416                 .init_hook = alc_automute_amp,
10417         },
10418         [ALC883_LAPTOP_EAPD] = {
10419                 .mixers = { alc883_base_mixer },
10420                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
10421                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10422                 .dac_nids = alc883_dac_nids,
10423                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10424                 .channel_mode = alc883_3ST_2ch_modes,
10425                 .input_mux = &alc883_capture_source,
10426         },
10427         [ALC883_CLEVO_M540R] = {
10428                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10429                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
10430                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10431                 .dac_nids = alc883_dac_nids,
10432                 .dig_out_nid = ALC883_DIGOUT_NID,
10433                 .dig_in_nid = ALC883_DIGIN_NID,
10434                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
10435                 .channel_mode = alc883_3ST_6ch_clevo_modes,
10436                 .need_dac_fix = 1,
10437                 .input_mux = &alc883_capture_source,
10438                 /* This machine has the hardware HP auto-muting, thus
10439                  * we need no software mute via unsol event
10440                  */
10441         },
10442         [ALC883_CLEVO_M720] = {
10443                 .mixers = { alc883_clevo_m720_mixer },
10444                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
10445                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10446                 .dac_nids = alc883_dac_nids,
10447                 .dig_out_nid = ALC883_DIGOUT_NID,
10448                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10449                 .channel_mode = alc883_3ST_2ch_modes,
10450                 .input_mux = &alc883_capture_source,
10451                 .unsol_event = alc883_clevo_m720_unsol_event,
10452                 .setup = alc883_clevo_m720_setup,
10453                 .init_hook = alc883_clevo_m720_init_hook,
10454         },
10455         [ALC883_LENOVO_101E_2ch] = {
10456                 .mixers = { alc883_lenovo_101e_2ch_mixer},
10457                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
10458                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10459                 .dac_nids = alc883_dac_nids,
10460                 .adc_nids = alc883_adc_nids_alt,
10461                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10462                 .capsrc_nids = alc883_capsrc_nids,
10463                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10464                 .channel_mode = alc883_3ST_2ch_modes,
10465                 .input_mux = &alc883_lenovo_101e_capture_source,
10466                 .unsol_event = alc883_lenovo_101e_unsol_event,
10467                 .init_hook = alc883_lenovo_101e_all_automute,
10468         },
10469         [ALC883_LENOVO_NB0763] = {
10470                 .mixers = { alc883_lenovo_nb0763_mixer },
10471                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
10472                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10473                 .dac_nids = alc883_dac_nids,
10474                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10475                 .channel_mode = alc883_3ST_2ch_modes,
10476                 .need_dac_fix = 1,
10477                 .input_mux = &alc883_lenovo_nb0763_capture_source,
10478                 .unsol_event = alc_automute_amp_unsol_event,
10479                 .setup = alc883_lenovo_nb0763_setup,
10480                 .init_hook = alc_automute_amp,
10481         },
10482         [ALC888_LENOVO_MS7195_DIG] = {
10483                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10484                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
10485                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10486                 .dac_nids = alc883_dac_nids,
10487                 .dig_out_nid = ALC883_DIGOUT_NID,
10488                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10489                 .channel_mode = alc883_3ST_6ch_modes,
10490                 .need_dac_fix = 1,
10491                 .input_mux = &alc883_capture_source,
10492                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
10493                 .init_hook = alc888_lenovo_ms7195_front_automute,
10494         },
10495         [ALC883_HAIER_W66] = {
10496                 .mixers = { alc883_targa_2ch_mixer},
10497                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
10498                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10499                 .dac_nids = alc883_dac_nids,
10500                 .dig_out_nid = ALC883_DIGOUT_NID,
10501                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10502                 .channel_mode = alc883_3ST_2ch_modes,
10503                 .input_mux = &alc883_capture_source,
10504                 .unsol_event = alc_automute_amp_unsol_event,
10505                 .setup = alc883_haier_w66_setup,
10506                 .init_hook = alc_automute_amp,
10507         },
10508         [ALC888_3ST_HP] = {
10509                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10510                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
10511                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10512                 .dac_nids = alc883_dac_nids,
10513                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
10514                 .channel_mode = alc888_3st_hp_modes,
10515                 .need_dac_fix = 1,
10516                 .input_mux = &alc883_capture_source,
10517                 .unsol_event = alc_automute_amp_unsol_event,
10518                 .setup = alc888_3st_hp_setup,
10519                 .init_hook = alc_automute_amp,
10520         },
10521         [ALC888_6ST_DELL] = {
10522                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10523                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
10524                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10525                 .dac_nids = alc883_dac_nids,
10526                 .dig_out_nid = ALC883_DIGOUT_NID,
10527                 .dig_in_nid = ALC883_DIGIN_NID,
10528                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10529                 .channel_mode = alc883_sixstack_modes,
10530                 .input_mux = &alc883_capture_source,
10531                 .unsol_event = alc_automute_amp_unsol_event,
10532                 .setup = alc888_6st_dell_setup,
10533                 .init_hook = alc_automute_amp,
10534         },
10535         [ALC883_MITAC] = {
10536                 .mixers = { alc883_mitac_mixer },
10537                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
10538                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10539                 .dac_nids = alc883_dac_nids,
10540                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10541                 .channel_mode = alc883_3ST_2ch_modes,
10542                 .input_mux = &alc883_capture_source,
10543                 .unsol_event = alc_automute_amp_unsol_event,
10544                 .setup = alc883_mitac_setup,
10545                 .init_hook = alc_automute_amp,
10546         },
10547         [ALC883_FUJITSU_PI2515] = {
10548                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
10549                 .init_verbs = { alc883_init_verbs,
10550                                 alc883_2ch_fujitsu_pi2515_verbs},
10551                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10552                 .dac_nids = alc883_dac_nids,
10553                 .dig_out_nid = ALC883_DIGOUT_NID,
10554                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10555                 .channel_mode = alc883_3ST_2ch_modes,
10556                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10557                 .unsol_event = alc_automute_amp_unsol_event,
10558                 .setup = alc883_2ch_fujitsu_pi2515_setup,
10559                 .init_hook = alc_automute_amp,
10560         },
10561         [ALC888_FUJITSU_XA3530] = {
10562                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
10563                 .init_verbs = { alc883_init_verbs,
10564                         alc888_fujitsu_xa3530_verbs },
10565                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10566                 .dac_nids = alc883_dac_nids,
10567                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10568                 .adc_nids = alc883_adc_nids_rev,
10569                 .capsrc_nids = alc883_capsrc_nids_rev,
10570                 .dig_out_nid = ALC883_DIGOUT_NID,
10571                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
10572                 .channel_mode = alc888_4ST_8ch_intel_modes,
10573                 .num_mux_defs =
10574                         ARRAY_SIZE(alc888_2_capture_sources),
10575                 .input_mux = alc888_2_capture_sources,
10576                 .unsol_event = alc_automute_amp_unsol_event,
10577                 .setup = alc888_fujitsu_xa3530_setup,
10578                 .init_hook = alc_automute_amp,
10579         },
10580         [ALC888_LENOVO_SKY] = {
10581                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
10582                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
10583                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10584                 .dac_nids = alc883_dac_nids,
10585                 .dig_out_nid = ALC883_DIGOUT_NID,
10586                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10587                 .channel_mode = alc883_sixstack_modes,
10588                 .need_dac_fix = 1,
10589                 .input_mux = &alc883_lenovo_sky_capture_source,
10590                 .unsol_event = alc_automute_amp_unsol_event,
10591                 .setup = alc888_lenovo_sky_setup,
10592                 .init_hook = alc_automute_amp,
10593         },
10594         [ALC888_ASUS_M90V] = {
10595                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10596                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10597                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10598                 .dac_nids = alc883_dac_nids,
10599                 .dig_out_nid = ALC883_DIGOUT_NID,
10600                 .dig_in_nid = ALC883_DIGIN_NID,
10601                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10602                 .channel_mode = alc883_3ST_6ch_modes,
10603                 .need_dac_fix = 1,
10604                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10605                 .unsol_event = alc_sku_unsol_event,
10606                 .setup = alc883_mode2_setup,
10607                 .init_hook = alc_inithook,
10608         },
10609         [ALC888_ASUS_EEE1601] = {
10610                 .mixers = { alc883_asus_eee1601_mixer },
10611                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
10612                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10613                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10614                 .dac_nids = alc883_dac_nids,
10615                 .dig_out_nid = ALC883_DIGOUT_NID,
10616                 .dig_in_nid = ALC883_DIGIN_NID,
10617                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10618                 .channel_mode = alc883_3ST_2ch_modes,
10619                 .need_dac_fix = 1,
10620                 .input_mux = &alc883_asus_eee1601_capture_source,
10621                 .unsol_event = alc_sku_unsol_event,
10622                 .init_hook = alc883_eee1601_inithook,
10623         },
10624         [ALC1200_ASUS_P5Q] = {
10625                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10626                 .init_verbs = { alc883_init_verbs },
10627                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10628                 .dac_nids = alc883_dac_nids,
10629                 .dig_out_nid = ALC1200_DIGOUT_NID,
10630                 .dig_in_nid = ALC883_DIGIN_NID,
10631                 .slave_dig_outs = alc1200_slave_dig_outs,
10632                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10633                 .channel_mode = alc883_sixstack_modes,
10634                 .input_mux = &alc883_capture_source,
10635         },
10636         [ALC889A_MB31] = {
10637                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10638                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10639                         alc880_gpio1_init_verbs },
10640                 .adc_nids = alc883_adc_nids,
10641                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10642                 .capsrc_nids = alc883_capsrc_nids,
10643                 .dac_nids = alc883_dac_nids,
10644                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10645                 .channel_mode = alc889A_mb31_6ch_modes,
10646                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10647                 .input_mux = &alc889A_mb31_capture_source,
10648                 .dig_out_nid = ALC883_DIGOUT_NID,
10649                 .unsol_event = alc889A_mb31_unsol_event,
10650                 .init_hook = alc889A_mb31_automute,
10651         },
10652         [ALC883_SONY_VAIO_TT] = {
10653                 .mixers = { alc883_vaiott_mixer },
10654                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10655                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10656                 .dac_nids = alc883_dac_nids,
10657                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10658                 .channel_mode = alc883_3ST_2ch_modes,
10659                 .input_mux = &alc883_capture_source,
10660                 .unsol_event = alc_automute_amp_unsol_event,
10661                 .setup = alc883_vaiott_setup,
10662                 .init_hook = alc_automute_amp,
10663         },
10664 };
10665
10666
10667 /*
10668  * Pin config fixes
10669  */
10670 enum {
10671         PINFIX_ABIT_AW9D_MAX,
10672         PINFIX_PB_M5210,
10673         PINFIX_ACER_ASPIRE_7736,
10674 };
10675
10676 static const struct alc_fixup alc882_fixups[] = {
10677         [PINFIX_ABIT_AW9D_MAX] = {
10678                 .pins = (const struct alc_pincfg[]) {
10679                         { 0x15, 0x01080104 }, /* side */
10680                         { 0x16, 0x01011012 }, /* rear */
10681                         { 0x17, 0x01016011 }, /* clfe */
10682                         { }
10683                 }
10684         },
10685         [PINFIX_PB_M5210] = {
10686                 .verbs = (const struct hda_verb[]) {
10687                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
10688                         {}
10689                 }
10690         },
10691         [PINFIX_ACER_ASPIRE_7736] = {
10692                 .sku = ALC_FIXUP_SKU_IGNORE,
10693         },
10694 };
10695
10696 static struct snd_pci_quirk alc882_fixup_tbl[] = {
10697         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
10698         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
10699         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
10700         {}
10701 };
10702
10703 /*
10704  * BIOS auto configuration
10705  */
10706 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
10707                                                 const struct auto_pin_cfg *cfg)
10708 {
10709         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
10710 }
10711
10712 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
10713                                               hda_nid_t nid, int pin_type,
10714                                               hda_nid_t dac)
10715 {
10716         int idx;
10717
10718         /* set as output */
10719         alc_set_pin_output(codec, nid, pin_type);
10720
10721         if (dac == 0x25)
10722                 idx = 4;
10723         else if (dac >= 0x02 && dac <= 0x05)
10724                 idx = dac - 2;
10725         else
10726                 return;
10727         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
10728 }
10729
10730 static void alc882_auto_init_multi_out(struct hda_codec *codec)
10731 {
10732         struct alc_spec *spec = codec->spec;
10733         int i;
10734
10735         for (i = 0; i <= HDA_SIDE; i++) {
10736                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
10737                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
10738                 if (nid)
10739                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
10740                                         spec->multiout.dac_nids[i]);
10741         }
10742 }
10743
10744 static void alc882_auto_init_hp_out(struct hda_codec *codec)
10745 {
10746         struct alc_spec *spec = codec->spec;
10747         hda_nid_t pin, dac;
10748         int i;
10749
10750         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
10751                 pin = spec->autocfg.hp_pins[i];
10752                 if (!pin)
10753                         break;
10754                 dac = spec->multiout.hp_nid;
10755                 if (!dac)
10756                         dac = spec->multiout.dac_nids[0]; /* to front */
10757                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
10758         }
10759         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
10760                 pin = spec->autocfg.speaker_pins[i];
10761                 if (!pin)
10762                         break;
10763                 dac = spec->multiout.extra_out_nid[0];
10764                 if (!dac)
10765                         dac = spec->multiout.dac_nids[0]; /* to front */
10766                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
10767         }
10768 }
10769
10770 static void alc882_auto_init_analog_input(struct hda_codec *codec)
10771 {
10772         struct alc_spec *spec = codec->spec;
10773         struct auto_pin_cfg *cfg = &spec->autocfg;
10774         int i;
10775
10776         for (i = 0; i < cfg->num_inputs; i++) {
10777                 hda_nid_t nid = cfg->inputs[i].pin;
10778                 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
10779                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
10780                         snd_hda_codec_write(codec, nid, 0,
10781                                             AC_VERB_SET_AMP_GAIN_MUTE,
10782                                             AMP_OUT_MUTE);
10783         }
10784 }
10785
10786 static void alc882_auto_init_input_src(struct hda_codec *codec)
10787 {
10788         struct alc_spec *spec = codec->spec;
10789         int c;
10790
10791         for (c = 0; c < spec->num_adc_nids; c++) {
10792                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
10793                 hda_nid_t nid = spec->capsrc_nids[c];
10794                 unsigned int mux_idx;
10795                 const struct hda_input_mux *imux;
10796                 int conns, mute, idx, item;
10797
10798                 conns = snd_hda_get_connections(codec, nid, conn_list,
10799                                                 ARRAY_SIZE(conn_list));
10800                 if (conns < 0)
10801                         continue;
10802                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
10803                 imux = &spec->input_mux[mux_idx];
10804                 if (!imux->num_items && mux_idx > 0)
10805                         imux = &spec->input_mux[0];
10806                 for (idx = 0; idx < conns; idx++) {
10807                         /* if the current connection is the selected one,
10808                          * unmute it as default - otherwise mute it
10809                          */
10810                         mute = AMP_IN_MUTE(idx);
10811                         for (item = 0; item < imux->num_items; item++) {
10812                                 if (imux->items[item].index == idx) {
10813                                         if (spec->cur_mux[c] == item)
10814                                                 mute = AMP_IN_UNMUTE(idx);
10815                                         break;
10816                                 }
10817                         }
10818                         /* check if we have a selector or mixer
10819                          * we could check for the widget type instead, but
10820                          * just check for Amp-In presence (in case of mixer
10821                          * without amp-in there is something wrong, this
10822                          * function shouldn't be used or capsrc nid is wrong)
10823                          */
10824                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
10825                                 snd_hda_codec_write(codec, nid, 0,
10826                                                     AC_VERB_SET_AMP_GAIN_MUTE,
10827                                                     mute);
10828                         else if (mute != AMP_IN_MUTE(idx))
10829                                 snd_hda_codec_write(codec, nid, 0,
10830                                                     AC_VERB_SET_CONNECT_SEL,
10831                                                     idx);
10832                 }
10833         }
10834 }
10835
10836 /* add mic boosts if needed */
10837 static int alc_auto_add_mic_boost(struct hda_codec *codec)
10838 {
10839         struct alc_spec *spec = codec->spec;
10840         struct auto_pin_cfg *cfg = &spec->autocfg;
10841         int i, err;
10842         hda_nid_t nid;
10843
10844         for (i = 0; i < cfg->num_inputs; i++) {
10845                 if (cfg->inputs[i].type > AUTO_PIN_MIC)
10846                         break;
10847                 nid = cfg->inputs[i].pin;
10848                 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
10849                         char label[32];
10850                         snprintf(label, sizeof(label), "%s Boost",
10851                                  hda_get_autocfg_input_label(codec, cfg, i));
10852                         err = add_control(spec, ALC_CTL_WIDGET_VOL, label, 0,
10853                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10854                         if (err < 0)
10855                                 return err;
10856                 }
10857         }
10858         return 0;
10859 }
10860
10861 /* almost identical with ALC880 parser... */
10862 static int alc882_parse_auto_config(struct hda_codec *codec)
10863 {
10864         struct alc_spec *spec = codec->spec;
10865         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10866         int err;
10867
10868         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10869                                            alc882_ignore);
10870         if (err < 0)
10871                 return err;
10872         if (!spec->autocfg.line_outs)
10873                 return 0; /* can't find valid BIOS pin config */
10874
10875         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10876         if (err < 0)
10877                 return err;
10878         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10879         if (err < 0)
10880                 return err;
10881         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10882                                            "Headphone");
10883         if (err < 0)
10884                 return err;
10885         err = alc880_auto_create_extra_out(spec,
10886                                            spec->autocfg.speaker_pins[0],
10887                                            "Speaker");
10888         if (err < 0)
10889                 return err;
10890         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10891         if (err < 0)
10892                 return err;
10893
10894         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10895
10896         alc_auto_parse_digital(codec);
10897
10898         if (spec->kctls.list)
10899                 add_mixer(spec, spec->kctls.list);
10900
10901         add_verb(spec, alc883_auto_init_verbs);
10902         /* if ADC 0x07 is available, initialize it, too */
10903         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10904                 add_verb(spec, alc882_adc1_init_verbs);
10905
10906         spec->num_mux_defs = 1;
10907         spec->input_mux = &spec->private_imux[0];
10908
10909         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
10910
10911         err = alc_auto_add_mic_boost(codec);
10912         if (err < 0)
10913                 return err;
10914
10915         return 1; /* config found */
10916 }
10917
10918 /* additional initialization for auto-configuration model */
10919 static void alc882_auto_init(struct hda_codec *codec)
10920 {
10921         struct alc_spec *spec = codec->spec;
10922         alc882_auto_init_multi_out(codec);
10923         alc882_auto_init_hp_out(codec);
10924         alc882_auto_init_analog_input(codec);
10925         alc882_auto_init_input_src(codec);
10926         alc_auto_init_digital(codec);
10927         if (spec->unsol_event)
10928                 alc_inithook(codec);
10929 }
10930
10931 static int patch_alc882(struct hda_codec *codec)
10932 {
10933         struct alc_spec *spec;
10934         int err, board_config;
10935
10936         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10937         if (spec == NULL)
10938                 return -ENOMEM;
10939
10940         codec->spec = spec;
10941
10942         switch (codec->vendor_id) {
10943         case 0x10ec0882:
10944         case 0x10ec0885:
10945                 break;
10946         default:
10947                 /* ALC883 and variants */
10948                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10949                 break;
10950         }
10951
10952         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10953                                                   alc882_models,
10954                                                   alc882_cfg_tbl);
10955
10956         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10957                 board_config = snd_hda_check_board_codec_sid_config(codec,
10958                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10959
10960         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10961                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10962                        codec->chip_name);
10963                 board_config = ALC882_AUTO;
10964         }
10965
10966         if (board_config == ALC882_AUTO)
10967                 alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 1);
10968
10969         alc_auto_parse_customize_define(codec);
10970
10971         if (board_config == ALC882_AUTO) {
10972                 /* automatic parse from the BIOS config */
10973                 err = alc882_parse_auto_config(codec);
10974                 if (err < 0) {
10975                         alc_free(codec);
10976                         return err;
10977                 } else if (!err) {
10978                         printk(KERN_INFO
10979                                "hda_codec: Cannot set up configuration "
10980                                "from BIOS.  Using base mode...\n");
10981                         board_config = ALC882_3ST_DIG;
10982                 }
10983         }
10984
10985         if (has_cdefine_beep(codec)) {
10986                 err = snd_hda_attach_beep_device(codec, 0x1);
10987                 if (err < 0) {
10988                         alc_free(codec);
10989                         return err;
10990                 }
10991         }
10992
10993         if (board_config != ALC882_AUTO)
10994                 setup_preset(codec, &alc882_presets[board_config]);
10995
10996         spec->stream_analog_playback = &alc882_pcm_analog_playback;
10997         spec->stream_analog_capture = &alc882_pcm_analog_capture;
10998         /* FIXME: setup DAC5 */
10999         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
11000         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
11001
11002         spec->stream_digital_playback = &alc882_pcm_digital_playback;
11003         spec->stream_digital_capture = &alc882_pcm_digital_capture;
11004
11005         if (!spec->adc_nids && spec->input_mux) {
11006                 int i, j;
11007                 spec->num_adc_nids = 0;
11008                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
11009                         const struct hda_input_mux *imux = spec->input_mux;
11010                         hda_nid_t cap;
11011                         hda_nid_t items[16];
11012                         hda_nid_t nid = alc882_adc_nids[i];
11013                         unsigned int wcap = get_wcaps(codec, nid);
11014                         /* get type */
11015                         wcap = get_wcaps_type(wcap);
11016                         if (wcap != AC_WID_AUD_IN)
11017                                 continue;
11018                         spec->private_adc_nids[spec->num_adc_nids] = nid;
11019                         err = snd_hda_get_connections(codec, nid, &cap, 1);
11020                         if (err < 0)
11021                                 continue;
11022                         err = snd_hda_get_connections(codec, cap, items,
11023                                                       ARRAY_SIZE(items));
11024                         if (err < 0)
11025                                 continue;
11026                         for (j = 0; j < imux->num_items; j++)
11027                                 if (imux->items[j].index >= err)
11028                                         break;
11029                         if (j < imux->num_items)
11030                                 continue;
11031                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
11032                         spec->num_adc_nids++;
11033                 }
11034                 spec->adc_nids = spec->private_adc_nids;
11035                 spec->capsrc_nids = spec->private_capsrc_nids;
11036         }
11037
11038         set_capture_mixer(codec);
11039
11040         if (has_cdefine_beep(codec))
11041                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11042
11043         if (board_config == ALC882_AUTO)
11044                 alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 0);
11045
11046         spec->vmaster_nid = 0x0c;
11047
11048         codec->patch_ops = alc_patch_ops;
11049         if (board_config == ALC882_AUTO)
11050                 spec->init_hook = alc882_auto_init;
11051
11052         alc_init_jacks(codec);
11053 #ifdef CONFIG_SND_HDA_POWER_SAVE
11054         if (!spec->loopback.amplist)
11055                 spec->loopback.amplist = alc882_loopbacks;
11056 #endif
11057
11058         return 0;
11059 }
11060
11061
11062 /*
11063  * ALC262 support
11064  */
11065
11066 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
11067 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
11068
11069 #define alc262_dac_nids         alc260_dac_nids
11070 #define alc262_adc_nids         alc882_adc_nids
11071 #define alc262_adc_nids_alt     alc882_adc_nids_alt
11072 #define alc262_capsrc_nids      alc882_capsrc_nids
11073 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
11074
11075 #define alc262_modes            alc260_modes
11076 #define alc262_capture_source   alc882_capture_source
11077
11078 static hda_nid_t alc262_dmic_adc_nids[1] = {
11079         /* ADC0 */
11080         0x09
11081 };
11082
11083 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
11084
11085 static struct snd_kcontrol_new alc262_base_mixer[] = {
11086         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11087         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11088         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11089         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11090         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11091         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11092         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11093         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11094         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11095         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11096         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11097         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11098         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
11099         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11100         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
11101         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11102         { } /* end */
11103 };
11104
11105 /* update HP, line and mono-out pins according to the master switch */
11106 static void alc262_hp_master_update(struct hda_codec *codec)
11107 {
11108         struct alc_spec *spec = codec->spec;
11109         int val = spec->master_sw;
11110
11111         /* HP & line-out */
11112         snd_hda_codec_write_cache(codec, 0x1b, 0,
11113                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11114                                   val ? PIN_HP : 0);
11115         snd_hda_codec_write_cache(codec, 0x15, 0,
11116                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11117                                   val ? PIN_HP : 0);
11118         /* mono (speaker) depending on the HP jack sense */
11119         val = val && !spec->jack_present;
11120         snd_hda_codec_write_cache(codec, 0x16, 0,
11121                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11122                                   val ? PIN_OUT : 0);
11123 }
11124
11125 static void alc262_hp_bpc_automute(struct hda_codec *codec)
11126 {
11127         struct alc_spec *spec = codec->spec;
11128
11129         spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11130         alc262_hp_master_update(codec);
11131 }
11132
11133 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
11134 {
11135         if ((res >> 26) != ALC880_HP_EVENT)
11136                 return;
11137         alc262_hp_bpc_automute(codec);
11138 }
11139
11140 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
11141 {
11142         struct alc_spec *spec = codec->spec;
11143
11144         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11145         alc262_hp_master_update(codec);
11146 }
11147
11148 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
11149                                            unsigned int res)
11150 {
11151         if ((res >> 26) != ALC880_HP_EVENT)
11152                 return;
11153         alc262_hp_wildwest_automute(codec);
11154 }
11155
11156 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
11157
11158 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
11159                                    struct snd_ctl_elem_value *ucontrol)
11160 {
11161         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11162         struct alc_spec *spec = codec->spec;
11163         int val = !!*ucontrol->value.integer.value;
11164
11165         if (val == spec->master_sw)
11166                 return 0;
11167         spec->master_sw = val;
11168         alc262_hp_master_update(codec);
11169         return 1;
11170 }
11171
11172 #define ALC262_HP_MASTER_SWITCH                                 \
11173         {                                                       \
11174                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11175                 .name = "Master Playback Switch",               \
11176                 .info = snd_ctl_boolean_mono_info,              \
11177                 .get = alc262_hp_master_sw_get,                 \
11178                 .put = alc262_hp_master_sw_put,                 \
11179         }, \
11180         {                                                       \
11181                 .iface = NID_MAPPING,                           \
11182                 .name = "Master Playback Switch",               \
11183                 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
11184         }
11185
11186
11187 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
11188         ALC262_HP_MASTER_SWITCH,
11189         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11190         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11191         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11192         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11193                               HDA_OUTPUT),
11194         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11195                             HDA_OUTPUT),
11196         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11197         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11198         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11199         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11200         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11201         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11202         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11203         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11204         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11205         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11206         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
11207         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
11208         { } /* end */
11209 };
11210
11211 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
11212         ALC262_HP_MASTER_SWITCH,
11213         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11214         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11215         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11216         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11217         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11218                               HDA_OUTPUT),
11219         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11220                             HDA_OUTPUT),
11221         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
11222         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
11223         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
11224         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11225         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11226         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11227         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11228         { } /* end */
11229 };
11230
11231 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
11232         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11233         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11234         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
11235         { } /* end */
11236 };
11237
11238 /* mute/unmute internal speaker according to the hp jack and mute state */
11239 static void alc262_hp_t5735_setup(struct hda_codec *codec)
11240 {
11241         struct alc_spec *spec = codec->spec;
11242
11243         spec->autocfg.hp_pins[0] = 0x15;
11244         spec->autocfg.speaker_pins[0] = 0x14;
11245 }
11246
11247 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
11248         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11249         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11250         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11251         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11252         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11253         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11254         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11255         { } /* end */
11256 };
11257
11258 static struct hda_verb alc262_hp_t5735_verbs[] = {
11259         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11260         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11261
11262         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11263         { }
11264 };
11265
11266 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
11267         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11268         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11269         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
11270         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
11271         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11272         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11273         { } /* end */
11274 };
11275
11276 static struct hda_verb alc262_hp_rp5700_verbs[] = {
11277         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11278         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11279         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11280         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11281         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11282         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11283         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11284         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11285         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11286         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11287         {}
11288 };
11289
11290 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
11291         .num_items = 1,
11292         .items = {
11293                 { "Line", 0x1 },
11294         },
11295 };
11296
11297 /* bind hp and internal speaker mute (with plug check) as master switch */
11298 static void alc262_hippo_master_update(struct hda_codec *codec)
11299 {
11300         struct alc_spec *spec = codec->spec;
11301         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11302         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11303         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11304         unsigned int mute;
11305
11306         /* HP */
11307         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
11308         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
11309                                  HDA_AMP_MUTE, mute);
11310         /* mute internal speaker per jack sense */
11311         if (spec->jack_present)
11312                 mute = HDA_AMP_MUTE;
11313         if (line_nid)
11314                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
11315                                          HDA_AMP_MUTE, mute);
11316         if (speaker_nid && speaker_nid != line_nid)
11317                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
11318                                          HDA_AMP_MUTE, mute);
11319 }
11320
11321 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
11322
11323 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
11324                                       struct snd_ctl_elem_value *ucontrol)
11325 {
11326         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11327         struct alc_spec *spec = codec->spec;
11328         int val = !!*ucontrol->value.integer.value;
11329
11330         if (val == spec->master_sw)
11331                 return 0;
11332         spec->master_sw = val;
11333         alc262_hippo_master_update(codec);
11334         return 1;
11335 }
11336
11337 #define ALC262_HIPPO_MASTER_SWITCH                              \
11338         {                                                       \
11339                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11340                 .name = "Master Playback Switch",               \
11341                 .info = snd_ctl_boolean_mono_info,              \
11342                 .get = alc262_hippo_master_sw_get,              \
11343                 .put = alc262_hippo_master_sw_put,              \
11344         },                                                      \
11345         {                                                       \
11346                 .iface = NID_MAPPING,                           \
11347                 .name = "Master Playback Switch",               \
11348                 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
11349                              (SUBDEV_SPEAKER(0) << 16), \
11350         }
11351
11352 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
11353         ALC262_HIPPO_MASTER_SWITCH,
11354         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11355         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11356         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11357         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11358         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11359         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11360         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11361         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11362         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11363         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11364         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11365         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11366         { } /* end */
11367 };
11368
11369 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
11370         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11371         ALC262_HIPPO_MASTER_SWITCH,
11372         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11373         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11374         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11375         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11376         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11377         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11378         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11379         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11380         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11381         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11382         { } /* end */
11383 };
11384
11385 /* mute/unmute internal speaker according to the hp jack and mute state */
11386 static void alc262_hippo_automute(struct hda_codec *codec)
11387 {
11388         struct alc_spec *spec = codec->spec;
11389         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11390
11391         spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
11392         alc262_hippo_master_update(codec);
11393 }
11394
11395 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
11396 {
11397         if ((res >> 26) != ALC880_HP_EVENT)
11398                 return;
11399         alc262_hippo_automute(codec);
11400 }
11401
11402 static void alc262_hippo_setup(struct hda_codec *codec)
11403 {
11404         struct alc_spec *spec = codec->spec;
11405
11406         spec->autocfg.hp_pins[0] = 0x15;
11407         spec->autocfg.speaker_pins[0] = 0x14;
11408 }
11409
11410 static void alc262_hippo1_setup(struct hda_codec *codec)
11411 {
11412         struct alc_spec *spec = codec->spec;
11413
11414         spec->autocfg.hp_pins[0] = 0x1b;
11415         spec->autocfg.speaker_pins[0] = 0x14;
11416 }
11417
11418
11419 static struct snd_kcontrol_new alc262_sony_mixer[] = {
11420         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11421         ALC262_HIPPO_MASTER_SWITCH,
11422         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11423         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11424         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11425         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11426         { } /* end */
11427 };
11428
11429 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
11430         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11431         ALC262_HIPPO_MASTER_SWITCH,
11432         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11433         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11434         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11435         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11436         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11437         { } /* end */
11438 };
11439
11440 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
11441         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11442         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11443         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
11444         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
11445         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11446         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11447         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11448         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11449         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11450         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11451         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11452         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11453         { } /* end */
11454 };
11455
11456 static struct hda_verb alc262_tyan_verbs[] = {
11457         /* Headphone automute */
11458         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11459         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11460         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11461
11462         /* P11 AUX_IN, white 4-pin connector */
11463         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11464         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
11465         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
11466         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
11467
11468         {}
11469 };
11470
11471 /* unsolicited event for HP jack sensing */
11472 static void alc262_tyan_setup(struct hda_codec *codec)
11473 {
11474         struct alc_spec *spec = codec->spec;
11475
11476         spec->autocfg.hp_pins[0] = 0x1b;
11477         spec->autocfg.speaker_pins[0] = 0x15;
11478 }
11479
11480
11481 #define alc262_capture_mixer            alc882_capture_mixer
11482 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
11483
11484 /*
11485  * generic initialization of ADC, input mixers and output mixers
11486  */
11487 static struct hda_verb alc262_init_verbs[] = {
11488         /*
11489          * Unmute ADC0-2 and set the default input to mic-in
11490          */
11491         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11492         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11493         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11494         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11495         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11496         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11497
11498         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11499          * mixer widget
11500          * Note: PASD motherboards uses the Line In 2 as the input for
11501          * front panel mic (mic 2)
11502          */
11503         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11504         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11505         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11506         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11507         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11508         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11509
11510         /*
11511          * Set up output mixers (0x0c - 0x0e)
11512          */
11513         /* set vol=0 to output mixers */
11514         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11515         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11516         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11517         /* set up input amps for analog loopback */
11518         /* Amp Indices: DAC = 0, mixer = 1 */
11519         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11520         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11521         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11522         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11523         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11524         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11525
11526         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11527         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11528         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11529         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11530         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11531         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11532
11533         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11534         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11535         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11536         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11537         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11538
11539         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11540         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11541
11542         /* FIXME: use matrix-type input source selection */
11543         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11544         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11545         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11546         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11547         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11548         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11549         /* Input mixer2 */
11550         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11551         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11552         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11553         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11554         /* Input mixer3 */
11555         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11556         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11557         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11558         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11559
11560         { }
11561 };
11562
11563 static struct hda_verb alc262_eapd_verbs[] = {
11564         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11565         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11566         { }
11567 };
11568
11569 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
11570         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11571         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11572         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11573
11574         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11575         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11576         {}
11577 };
11578
11579 static struct hda_verb alc262_sony_unsol_verbs[] = {
11580         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11581         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11582         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
11583
11584         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11585         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11586         {}
11587 };
11588
11589 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
11590         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11591         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11592         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11593         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11594         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11595         { } /* end */
11596 };
11597
11598 static struct hda_verb alc262_toshiba_s06_verbs[] = {
11599         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11600         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11601         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11602         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11603         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
11604         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11605         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11606         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11607         {}
11608 };
11609
11610 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11611 {
11612         struct alc_spec *spec = codec->spec;
11613
11614         spec->autocfg.hp_pins[0] = 0x15;
11615         spec->autocfg.speaker_pins[0] = 0x14;
11616         spec->ext_mic.pin = 0x18;
11617         spec->ext_mic.mux_idx = 0;
11618         spec->int_mic.pin = 0x12;
11619         spec->int_mic.mux_idx = 9;
11620         spec->auto_mic = 1;
11621 }
11622
11623 /*
11624  * nec model
11625  *  0x15 = headphone
11626  *  0x16 = internal speaker
11627  *  0x18 = external mic
11628  */
11629
11630 static struct snd_kcontrol_new alc262_nec_mixer[] = {
11631         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11632         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11633
11634         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11635         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11636         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11637
11638         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11639         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11640         { } /* end */
11641 };
11642
11643 static struct hda_verb alc262_nec_verbs[] = {
11644         /* Unmute Speaker */
11645         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11646
11647         /* Headphone */
11648         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11649         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11650
11651         /* External mic to headphone */
11652         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11653         /* External mic to speaker */
11654         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11655         {}
11656 };
11657
11658 /*
11659  * fujitsu model
11660  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11661  *  0x1b = port replicator headphone out
11662  */
11663
11664 #define ALC_HP_EVENT    0x37
11665
11666 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11667         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11668         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11669         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11670         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11671         {}
11672 };
11673
11674 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11675         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11676         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11677         {}
11678 };
11679
11680 static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11681         /* Front Mic pin: input vref at 50% */
11682         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11683         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11684         {}
11685 };
11686
11687 static struct hda_input_mux alc262_fujitsu_capture_source = {
11688         .num_items = 3,
11689         .items = {
11690                 { "Mic", 0x0 },
11691                 { "Int Mic", 0x1 },
11692                 { "CD", 0x4 },
11693         },
11694 };
11695
11696 static struct hda_input_mux alc262_HP_capture_source = {
11697         .num_items = 5,
11698         .items = {
11699                 { "Mic", 0x0 },
11700                 { "Front Mic", 0x1 },
11701                 { "Line", 0x2 },
11702                 { "CD", 0x4 },
11703                 { "AUX IN", 0x6 },
11704         },
11705 };
11706
11707 static struct hda_input_mux alc262_HP_D7000_capture_source = {
11708         .num_items = 4,
11709         .items = {
11710                 { "Mic", 0x0 },
11711                 { "Front Mic", 0x2 },
11712                 { "Line", 0x1 },
11713                 { "CD", 0x4 },
11714         },
11715 };
11716
11717 /* mute/unmute internal speaker according to the hp jacks and mute state */
11718 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
11719 {
11720         struct alc_spec *spec = codec->spec;
11721         unsigned int mute;
11722
11723         if (force || !spec->sense_updated) {
11724                 spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
11725                                      snd_hda_jack_detect(codec, 0x1b);
11726                 spec->sense_updated = 1;
11727         }
11728         /* unmute internal speaker only if both HPs are unplugged and
11729          * master switch is on
11730          */
11731         if (spec->jack_present)
11732                 mute = HDA_AMP_MUTE;
11733         else
11734                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11735         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11736                                  HDA_AMP_MUTE, mute);
11737 }
11738
11739 /* unsolicited event for HP jack sensing */
11740 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
11741                                        unsigned int res)
11742 {
11743         if ((res >> 26) != ALC_HP_EVENT)
11744                 return;
11745         alc262_fujitsu_automute(codec, 1);
11746 }
11747
11748 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
11749 {
11750         alc262_fujitsu_automute(codec, 1);
11751 }
11752
11753 /* bind volumes of both NID 0x0c and 0x0d */
11754 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11755         .ops = &snd_hda_bind_vol,
11756         .values = {
11757                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11758                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11759                 0
11760         },
11761 };
11762
11763 /* mute/unmute internal speaker according to the hp jack and mute state */
11764 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
11765 {
11766         struct alc_spec *spec = codec->spec;
11767         unsigned int mute;
11768
11769         if (force || !spec->sense_updated) {
11770                 spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11771                 spec->sense_updated = 1;
11772         }
11773         if (spec->jack_present) {
11774                 /* mute internal speaker */
11775                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11776                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11777                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11778                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11779         } else {
11780                 /* unmute internal speaker if necessary */
11781                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
11782                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11783                                          HDA_AMP_MUTE, mute);
11784                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11785                                          HDA_AMP_MUTE, mute);
11786         }
11787 }
11788
11789 /* unsolicited event for HP jack sensing */
11790 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
11791                                        unsigned int res)
11792 {
11793         if ((res >> 26) != ALC_HP_EVENT)
11794                 return;
11795         alc262_lenovo_3000_automute(codec, 1);
11796 }
11797
11798 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
11799                                   int dir, int idx, long *valp)
11800 {
11801         int i, change = 0;
11802
11803         for (i = 0; i < 2; i++, valp++)
11804                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
11805                                                    HDA_AMP_MUTE,
11806                                                    *valp ? 0 : HDA_AMP_MUTE);
11807         return change;
11808 }
11809
11810 /* bind hp and internal speaker mute (with plug check) */
11811 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
11812                                          struct snd_ctl_elem_value *ucontrol)
11813 {
11814         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11815         long *valp = ucontrol->value.integer.value;
11816         int change;
11817
11818         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11819         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11820         if (change)
11821                 alc262_fujitsu_automute(codec, 0);
11822         return change;
11823 }
11824
11825 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
11826         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11827         {
11828                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11829                 .name = "Master Playback Switch",
11830                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11831                 .info = snd_hda_mixer_amp_switch_info,
11832                 .get = snd_hda_mixer_amp_switch_get,
11833                 .put = alc262_fujitsu_master_sw_put,
11834                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11835         },
11836         {
11837                 .iface = NID_MAPPING,
11838                 .name = "Master Playback Switch",
11839                 .private_value = 0x1b,
11840         },
11841         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11842         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11843         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11844         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11845         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11846         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11847         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11848         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11849         { } /* end */
11850 };
11851
11852 /* bind hp and internal speaker mute (with plug check) */
11853 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
11854                                          struct snd_ctl_elem_value *ucontrol)
11855 {
11856         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11857         long *valp = ucontrol->value.integer.value;
11858         int change;
11859
11860         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11861         if (change)
11862                 alc262_lenovo_3000_automute(codec, 0);
11863         return change;
11864 }
11865
11866 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
11867         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11868         {
11869                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11870                 .name = "Master Playback Switch",
11871                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11872                 .info = snd_hda_mixer_amp_switch_info,
11873                 .get = snd_hda_mixer_amp_switch_get,
11874                 .put = alc262_lenovo_3000_master_sw_put,
11875                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11876         },
11877         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11878         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11879         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11880         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11881         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11882         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11883         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11884         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11885         { } /* end */
11886 };
11887
11888 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11889         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11890         ALC262_HIPPO_MASTER_SWITCH,
11891         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11892         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11893         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11894         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11895         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11896         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11897         { } /* end */
11898 };
11899
11900 /* additional init verbs for Benq laptops */
11901 static struct hda_verb alc262_EAPD_verbs[] = {
11902         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11903         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11904         {}
11905 };
11906
11907 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11908         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11909         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11910
11911         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11912         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11913         {}
11914 };
11915
11916 /* Samsung Q1 Ultra Vista model setup */
11917 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11918         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11919         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11920         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11921         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11922         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
11923         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
11924         { } /* end */
11925 };
11926
11927 static struct hda_verb alc262_ultra_verbs[] = {
11928         /* output mixer */
11929         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11930         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11931         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11932         /* speaker */
11933         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11934         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11935         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11936         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11937         /* HP */
11938         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11939         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11940         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11941         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11942         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11943         /* internal mic */
11944         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11945         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11946         /* ADC, choose mic */
11947         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11948         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11949         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11950         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11951         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11952         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11953         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11954         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11955         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11956         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11957         {}
11958 };
11959
11960 /* mute/unmute internal speaker according to the hp jack and mute state */
11961 static void alc262_ultra_automute(struct hda_codec *codec)
11962 {
11963         struct alc_spec *spec = codec->spec;
11964         unsigned int mute;
11965
11966         mute = 0;
11967         /* auto-mute only when HP is used as HP */
11968         if (!spec->cur_mux[0]) {
11969                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11970                 if (spec->jack_present)
11971                         mute = HDA_AMP_MUTE;
11972         }
11973         /* mute/unmute internal speaker */
11974         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11975                                  HDA_AMP_MUTE, mute);
11976         /* mute/unmute HP */
11977         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11978                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
11979 }
11980
11981 /* unsolicited event for HP jack sensing */
11982 static void alc262_ultra_unsol_event(struct hda_codec *codec,
11983                                        unsigned int res)
11984 {
11985         if ((res >> 26) != ALC880_HP_EVENT)
11986                 return;
11987         alc262_ultra_automute(codec);
11988 }
11989
11990 static struct hda_input_mux alc262_ultra_capture_source = {
11991         .num_items = 2,
11992         .items = {
11993                 { "Mic", 0x1 },
11994                 { "Headphone", 0x7 },
11995         },
11996 };
11997
11998 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
11999                                      struct snd_ctl_elem_value *ucontrol)
12000 {
12001         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12002         struct alc_spec *spec = codec->spec;
12003         int ret;
12004
12005         ret = alc_mux_enum_put(kcontrol, ucontrol);
12006         if (!ret)
12007                 return 0;
12008         /* reprogram the HP pin as mic or HP according to the input source */
12009         snd_hda_codec_write_cache(codec, 0x15, 0,
12010                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
12011                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
12012         alc262_ultra_automute(codec); /* mute/unmute HP */
12013         return ret;
12014 }
12015
12016 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
12017         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
12018         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
12019         {
12020                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12021                 .name = "Capture Source",
12022                 .info = alc_mux_enum_info,
12023                 .get = alc_mux_enum_get,
12024                 .put = alc262_ultra_mux_enum_put,
12025         },
12026         {
12027                 .iface = NID_MAPPING,
12028                 .name = "Capture Source",
12029                 .private_value = 0x15,
12030         },
12031         { } /* end */
12032 };
12033
12034 /* We use two mixers depending on the output pin; 0x16 is a mono output
12035  * and thus it's bound with a different mixer.
12036  * This function returns which mixer amp should be used.
12037  */
12038 static int alc262_check_volbit(hda_nid_t nid)
12039 {
12040         if (!nid)
12041                 return 0;
12042         else if (nid == 0x16)
12043                 return 2;
12044         else
12045                 return 1;
12046 }
12047
12048 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
12049                                   const char *pfx, int *vbits, int idx)
12050 {
12051         unsigned long val;
12052         int vbit;
12053
12054         vbit = alc262_check_volbit(nid);
12055         if (!vbit)
12056                 return 0;
12057         if (*vbits & vbit) /* a volume control for this mixer already there */
12058                 return 0;
12059         *vbits |= vbit;
12060         if (vbit == 2)
12061                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
12062         else
12063                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
12064         return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val);
12065 }
12066
12067 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
12068                                  const char *pfx, int idx)
12069 {
12070         unsigned long val;
12071
12072         if (!nid)
12073                 return 0;
12074         if (nid == 0x16)
12075                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
12076         else
12077                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
12078         return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val);
12079 }
12080
12081 /* add playback controls from the parsed DAC table */
12082 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
12083                                              const struct auto_pin_cfg *cfg)
12084 {
12085         const char *pfx;
12086         int vbits;
12087         int i, err;
12088
12089         spec->multiout.num_dacs = 1;    /* only use one dac */
12090         spec->multiout.dac_nids = spec->private_dac_nids;
12091         spec->multiout.dac_nids[0] = 2;
12092
12093         if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
12094                 pfx = "Master";
12095         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12096                 pfx = "Speaker";
12097         else if (cfg->line_out_type == AUTO_PIN_HP_OUT)
12098                 pfx = "Headphone";
12099         else
12100                 pfx = "Front";
12101         for (i = 0; i < 2; i++) {
12102                 err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx, i);
12103                 if (err < 0)
12104                         return err;
12105                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12106                         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i],
12107                                                     "Speaker", i);
12108                         if (err < 0)
12109                                 return err;
12110                 }
12111                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12112                         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i],
12113                                                     "Headphone", i);
12114                         if (err < 0)
12115                                 return err;
12116                 }
12117         }
12118
12119         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
12120                 alc262_check_volbit(cfg->speaker_pins[0]) |
12121                 alc262_check_volbit(cfg->hp_pins[0]);
12122         if (vbits == 1 || vbits == 2)
12123                 pfx = "Master"; /* only one mixer is used */
12124         vbits = 0;
12125         for (i = 0; i < 2; i++) {
12126                 err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx,
12127                                              &vbits, i);
12128                 if (err < 0)
12129                         return err;
12130                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12131                         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i],
12132                                                      "Speaker", &vbits, i);
12133                         if (err < 0)
12134                                 return err;
12135                 }
12136                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12137                         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i],
12138                                                      "Headphone", &vbits, i);
12139                         if (err < 0)
12140                                 return err;
12141                 }
12142         }
12143         return 0;
12144 }
12145
12146 #define alc262_auto_create_input_ctls \
12147         alc882_auto_create_input_ctls
12148
12149 /*
12150  * generic initialization of ADC, input mixers and output mixers
12151  */
12152 static struct hda_verb alc262_volume_init_verbs[] = {
12153         /*
12154          * Unmute ADC0-2 and set the default input to mic-in
12155          */
12156         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12157         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12158         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12159         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12160         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12161         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12162
12163         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12164          * mixer widget
12165          * Note: PASD motherboards uses the Line In 2 as the input for
12166          * front panel mic (mic 2)
12167          */
12168         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12169         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12170         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12171         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12172         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12173         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12174
12175         /*
12176          * Set up output mixers (0x0c - 0x0f)
12177          */
12178         /* set vol=0 to output mixers */
12179         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12180         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12181         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12182
12183         /* set up input amps for analog loopback */
12184         /* Amp Indices: DAC = 0, mixer = 1 */
12185         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12186         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12187         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12188         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12189         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12190         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12191
12192         /* FIXME: use matrix-type input source selection */
12193         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12194         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12195         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12196         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12197         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12198         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12199         /* Input mixer2 */
12200         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12201         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12202         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12203         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12204         /* Input mixer3 */
12205         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12206         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12207         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12208         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12209
12210         { }
12211 };
12212
12213 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
12214         /*
12215          * Unmute ADC0-2 and set the default input to mic-in
12216          */
12217         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12218         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12219         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12220         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12221         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12222         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12223
12224         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12225          * mixer widget
12226          * Note: PASD motherboards uses the Line In 2 as the input for
12227          * front panel mic (mic 2)
12228          */
12229         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12230         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12231         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12232         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12233         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12234         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12235         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12236         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12237
12238         /*
12239          * Set up output mixers (0x0c - 0x0e)
12240          */
12241         /* set vol=0 to output mixers */
12242         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12243         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12244         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12245
12246         /* set up input amps for analog loopback */
12247         /* Amp Indices: DAC = 0, mixer = 1 */
12248         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12249         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12250         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12251         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12252         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12253         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12254
12255         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12256         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12257         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12258
12259         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12260         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12261
12262         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12263         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12264
12265         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12266         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12267         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12268         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12269         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12270
12271         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12272         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12273         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12274         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12275         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12276         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12277
12278
12279         /* FIXME: use matrix-type input source selection */
12280         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
12281         /* Input mixer1: only unmute Mic */
12282         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12283         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12284         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12285         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12286         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12287         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12288         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12289         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12290         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12291         /* Input mixer2 */
12292         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12293         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12294         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12295         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12296         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12297         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12298         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12299         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12300         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12301         /* Input mixer3 */
12302         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12303         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12304         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12305         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12306         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12307         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12308         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12309         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12310         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12311
12312         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12313
12314         { }
12315 };
12316
12317 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
12318         /*
12319          * Unmute ADC0-2 and set the default input to mic-in
12320          */
12321         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12322         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12323         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12324         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12325         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12326         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12327
12328         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12329          * mixer widget
12330          * Note: PASD motherboards uses the Line In 2 as the input for front
12331          * panel mic (mic 2)
12332          */
12333         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12334         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12335         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12336         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12337         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12338         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12339         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12340         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12341         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12342         /*
12343          * Set up output mixers (0x0c - 0x0e)
12344          */
12345         /* set vol=0 to output mixers */
12346         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12347         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12348         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12349
12350         /* set up input amps for analog loopback */
12351         /* Amp Indices: DAC = 0, mixer = 1 */
12352         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12353         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12354         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12355         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12356         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12357         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12358
12359
12360         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
12361         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
12362         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
12363         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
12364         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12365         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
12366         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
12367
12368         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12369         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12370
12371         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12372         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12373
12374         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
12375         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12376         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12377         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
12378         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12379         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12380
12381         /* FIXME: use matrix-type input source selection */
12382         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12383         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12384         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
12385         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
12386         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
12387         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
12388         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
12389         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
12390         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
12391         /* Input mixer2 */
12392         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12393         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12394         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12395         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12396         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12397         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12398         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12399         /* Input mixer3 */
12400         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12401         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12402         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12403         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12404         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12405         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12406         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12407
12408         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12409
12410         { }
12411 };
12412
12413 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
12414
12415         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
12416         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12417         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
12418
12419         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
12420         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12421         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12422         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12423
12424         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
12425         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12426         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12427         {}
12428 };
12429
12430 /*
12431  * Pin config fixes
12432  */
12433 enum {
12434         PINFIX_FSC_H270,
12435 };
12436
12437 static const struct alc_fixup alc262_fixups[] = {
12438         [PINFIX_FSC_H270] = {
12439                 .pins = (const struct alc_pincfg[]) {
12440                         { 0x14, 0x99130110 }, /* speaker */
12441                         { 0x15, 0x0221142f }, /* front HP */
12442                         { 0x1b, 0x0121141f }, /* rear HP */
12443                         { }
12444                 }
12445         },
12446         [PINFIX_PB_M5210] = {
12447                 .verbs = (const struct hda_verb[]) {
12448                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
12449                         {}
12450                 }
12451         },
12452 };
12453
12454 static struct snd_pci_quirk alc262_fixup_tbl[] = {
12455         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
12456         {}
12457 };
12458
12459
12460 #ifdef CONFIG_SND_HDA_POWER_SAVE
12461 #define alc262_loopbacks        alc880_loopbacks
12462 #endif
12463
12464 /* pcm configuration: identical with ALC880 */
12465 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
12466 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
12467 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
12468 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
12469
12470 /*
12471  * BIOS auto configuration
12472  */
12473 static int alc262_parse_auto_config(struct hda_codec *codec)
12474 {
12475         struct alc_spec *spec = codec->spec;
12476         int err;
12477         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
12478
12479         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12480                                            alc262_ignore);
12481         if (err < 0)
12482                 return err;
12483         if (!spec->autocfg.line_outs) {
12484                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12485                         spec->multiout.max_channels = 2;
12486                         spec->no_analog = 1;
12487                         goto dig_only;
12488                 }
12489                 return 0; /* can't find valid BIOS pin config */
12490         }
12491         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
12492         if (err < 0)
12493                 return err;
12494         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
12495         if (err < 0)
12496                 return err;
12497
12498         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12499
12500  dig_only:
12501         alc_auto_parse_digital(codec);
12502
12503         if (spec->kctls.list)
12504                 add_mixer(spec, spec->kctls.list);
12505
12506         add_verb(spec, alc262_volume_init_verbs);
12507         spec->num_mux_defs = 1;
12508         spec->input_mux = &spec->private_imux[0];
12509
12510         err = alc_auto_add_mic_boost(codec);
12511         if (err < 0)
12512                 return err;
12513
12514         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
12515
12516         return 1;
12517 }
12518
12519 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
12520 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
12521 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
12522 #define alc262_auto_init_input_src      alc882_auto_init_input_src
12523
12524
12525 /* init callback for auto-configuration model -- overriding the default init */
12526 static void alc262_auto_init(struct hda_codec *codec)
12527 {
12528         struct alc_spec *spec = codec->spec;
12529         alc262_auto_init_multi_out(codec);
12530         alc262_auto_init_hp_out(codec);
12531         alc262_auto_init_analog_input(codec);
12532         alc262_auto_init_input_src(codec);
12533         alc_auto_init_digital(codec);
12534         if (spec->unsol_event)
12535                 alc_inithook(codec);
12536 }
12537
12538 /*
12539  * configuration and preset
12540  */
12541 static const char *alc262_models[ALC262_MODEL_LAST] = {
12542         [ALC262_BASIC]          = "basic",
12543         [ALC262_HIPPO]          = "hippo",
12544         [ALC262_HIPPO_1]        = "hippo_1",
12545         [ALC262_FUJITSU]        = "fujitsu",
12546         [ALC262_HP_BPC]         = "hp-bpc",
12547         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
12548         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
12549         [ALC262_HP_RP5700]      = "hp-rp5700",
12550         [ALC262_BENQ_ED8]       = "benq",
12551         [ALC262_BENQ_T31]       = "benq-t31",
12552         [ALC262_SONY_ASSAMD]    = "sony-assamd",
12553         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
12554         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
12555         [ALC262_ULTRA]          = "ultra",
12556         [ALC262_LENOVO_3000]    = "lenovo-3000",
12557         [ALC262_NEC]            = "nec",
12558         [ALC262_TYAN]           = "tyan",
12559         [ALC262_AUTO]           = "auto",
12560 };
12561
12562 static struct snd_pci_quirk alc262_cfg_tbl[] = {
12563         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
12564         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
12565         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
12566                            ALC262_HP_BPC),
12567         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
12568                            ALC262_HP_BPC),
12569         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
12570                            ALC262_HP_BPC),
12571         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
12572         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
12573         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
12574         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
12575         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
12576         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
12577         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
12578         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
12579         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
12580         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
12581         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
12582         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
12583                       ALC262_HP_TC_T5735),
12584         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
12585         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12586         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
12587         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12588         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
12589         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
12590         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
12591         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
12592 #if 0 /* disable the quirk since model=auto works better in recent versions */
12593         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
12594                            ALC262_SONY_ASSAMD),
12595 #endif
12596         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
12597                       ALC262_TOSHIBA_RX1),
12598         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
12599         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
12600         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
12601         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
12602         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
12603                            ALC262_ULTRA),
12604         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
12605         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
12606         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
12607         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
12608         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
12609         {}
12610 };
12611
12612 static struct alc_config_preset alc262_presets[] = {
12613         [ALC262_BASIC] = {
12614                 .mixers = { alc262_base_mixer },
12615                 .init_verbs = { alc262_init_verbs },
12616                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12617                 .dac_nids = alc262_dac_nids,
12618                 .hp_nid = 0x03,
12619                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12620                 .channel_mode = alc262_modes,
12621                 .input_mux = &alc262_capture_source,
12622         },
12623         [ALC262_HIPPO] = {
12624                 .mixers = { alc262_hippo_mixer },
12625                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
12626                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12627                 .dac_nids = alc262_dac_nids,
12628                 .hp_nid = 0x03,
12629                 .dig_out_nid = ALC262_DIGOUT_NID,
12630                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12631                 .channel_mode = alc262_modes,
12632                 .input_mux = &alc262_capture_source,
12633                 .unsol_event = alc262_hippo_unsol_event,
12634                 .setup = alc262_hippo_setup,
12635                 .init_hook = alc262_hippo_automute,
12636         },
12637         [ALC262_HIPPO_1] = {
12638                 .mixers = { alc262_hippo1_mixer },
12639                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
12640                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12641                 .dac_nids = alc262_dac_nids,
12642                 .hp_nid = 0x02,
12643                 .dig_out_nid = ALC262_DIGOUT_NID,
12644                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12645                 .channel_mode = alc262_modes,
12646                 .input_mux = &alc262_capture_source,
12647                 .unsol_event = alc262_hippo_unsol_event,
12648                 .setup = alc262_hippo1_setup,
12649                 .init_hook = alc262_hippo_automute,
12650         },
12651         [ALC262_FUJITSU] = {
12652                 .mixers = { alc262_fujitsu_mixer },
12653                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12654                                 alc262_fujitsu_unsol_verbs },
12655                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12656                 .dac_nids = alc262_dac_nids,
12657                 .hp_nid = 0x03,
12658                 .dig_out_nid = ALC262_DIGOUT_NID,
12659                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12660                 .channel_mode = alc262_modes,
12661                 .input_mux = &alc262_fujitsu_capture_source,
12662                 .unsol_event = alc262_fujitsu_unsol_event,
12663                 .init_hook = alc262_fujitsu_init_hook,
12664         },
12665         [ALC262_HP_BPC] = {
12666                 .mixers = { alc262_HP_BPC_mixer },
12667                 .init_verbs = { alc262_HP_BPC_init_verbs },
12668                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12669                 .dac_nids = alc262_dac_nids,
12670                 .hp_nid = 0x03,
12671                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12672                 .channel_mode = alc262_modes,
12673                 .input_mux = &alc262_HP_capture_source,
12674                 .unsol_event = alc262_hp_bpc_unsol_event,
12675                 .init_hook = alc262_hp_bpc_automute,
12676         },
12677         [ALC262_HP_BPC_D7000_WF] = {
12678                 .mixers = { alc262_HP_BPC_WildWest_mixer },
12679                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12680                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12681                 .dac_nids = alc262_dac_nids,
12682                 .hp_nid = 0x03,
12683                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12684                 .channel_mode = alc262_modes,
12685                 .input_mux = &alc262_HP_D7000_capture_source,
12686                 .unsol_event = alc262_hp_wildwest_unsol_event,
12687                 .init_hook = alc262_hp_wildwest_automute,
12688         },
12689         [ALC262_HP_BPC_D7000_WL] = {
12690                 .mixers = { alc262_HP_BPC_WildWest_mixer,
12691                             alc262_HP_BPC_WildWest_option_mixer },
12692                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12693                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12694                 .dac_nids = alc262_dac_nids,
12695                 .hp_nid = 0x03,
12696                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12697                 .channel_mode = alc262_modes,
12698                 .input_mux = &alc262_HP_D7000_capture_source,
12699                 .unsol_event = alc262_hp_wildwest_unsol_event,
12700                 .init_hook = alc262_hp_wildwest_automute,
12701         },
12702         [ALC262_HP_TC_T5735] = {
12703                 .mixers = { alc262_hp_t5735_mixer },
12704                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12705                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12706                 .dac_nids = alc262_dac_nids,
12707                 .hp_nid = 0x03,
12708                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12709                 .channel_mode = alc262_modes,
12710                 .input_mux = &alc262_capture_source,
12711                 .unsol_event = alc_sku_unsol_event,
12712                 .setup = alc262_hp_t5735_setup,
12713                 .init_hook = alc_inithook,
12714         },
12715         [ALC262_HP_RP5700] = {
12716                 .mixers = { alc262_hp_rp5700_mixer },
12717                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12718                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12719                 .dac_nids = alc262_dac_nids,
12720                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12721                 .channel_mode = alc262_modes,
12722                 .input_mux = &alc262_hp_rp5700_capture_source,
12723         },
12724         [ALC262_BENQ_ED8] = {
12725                 .mixers = { alc262_base_mixer },
12726                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12727                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12728                 .dac_nids = alc262_dac_nids,
12729                 .hp_nid = 0x03,
12730                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12731                 .channel_mode = alc262_modes,
12732                 .input_mux = &alc262_capture_source,
12733         },
12734         [ALC262_SONY_ASSAMD] = {
12735                 .mixers = { alc262_sony_mixer },
12736                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12737                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12738                 .dac_nids = alc262_dac_nids,
12739                 .hp_nid = 0x02,
12740                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12741                 .channel_mode = alc262_modes,
12742                 .input_mux = &alc262_capture_source,
12743                 .unsol_event = alc262_hippo_unsol_event,
12744                 .setup = alc262_hippo_setup,
12745                 .init_hook = alc262_hippo_automute,
12746         },
12747         [ALC262_BENQ_T31] = {
12748                 .mixers = { alc262_benq_t31_mixer },
12749                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12750                                 alc_hp15_unsol_verbs },
12751                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12752                 .dac_nids = alc262_dac_nids,
12753                 .hp_nid = 0x03,
12754                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12755                 .channel_mode = alc262_modes,
12756                 .input_mux = &alc262_capture_source,
12757                 .unsol_event = alc262_hippo_unsol_event,
12758                 .setup = alc262_hippo_setup,
12759                 .init_hook = alc262_hippo_automute,
12760         },
12761         [ALC262_ULTRA] = {
12762                 .mixers = { alc262_ultra_mixer },
12763                 .cap_mixer = alc262_ultra_capture_mixer,
12764                 .init_verbs = { alc262_ultra_verbs },
12765                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12766                 .dac_nids = alc262_dac_nids,
12767                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12768                 .channel_mode = alc262_modes,
12769                 .input_mux = &alc262_ultra_capture_source,
12770                 .adc_nids = alc262_adc_nids, /* ADC0 */
12771                 .capsrc_nids = alc262_capsrc_nids,
12772                 .num_adc_nids = 1, /* single ADC */
12773                 .unsol_event = alc262_ultra_unsol_event,
12774                 .init_hook = alc262_ultra_automute,
12775         },
12776         [ALC262_LENOVO_3000] = {
12777                 .mixers = { alc262_lenovo_3000_mixer },
12778                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12779                                 alc262_lenovo_3000_unsol_verbs,
12780                                 alc262_lenovo_3000_init_verbs },
12781                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12782                 .dac_nids = alc262_dac_nids,
12783                 .hp_nid = 0x03,
12784                 .dig_out_nid = ALC262_DIGOUT_NID,
12785                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12786                 .channel_mode = alc262_modes,
12787                 .input_mux = &alc262_fujitsu_capture_source,
12788                 .unsol_event = alc262_lenovo_3000_unsol_event,
12789         },
12790         [ALC262_NEC] = {
12791                 .mixers = { alc262_nec_mixer },
12792                 .init_verbs = { alc262_nec_verbs },
12793                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12794                 .dac_nids = alc262_dac_nids,
12795                 .hp_nid = 0x03,
12796                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12797                 .channel_mode = alc262_modes,
12798                 .input_mux = &alc262_capture_source,
12799         },
12800         [ALC262_TOSHIBA_S06] = {
12801                 .mixers = { alc262_toshiba_s06_mixer },
12802                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12803                                                         alc262_eapd_verbs },
12804                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12805                 .capsrc_nids = alc262_dmic_capsrc_nids,
12806                 .dac_nids = alc262_dac_nids,
12807                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12808                 .num_adc_nids = 1, /* single ADC */
12809                 .dig_out_nid = ALC262_DIGOUT_NID,
12810                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12811                 .channel_mode = alc262_modes,
12812                 .unsol_event = alc_sku_unsol_event,
12813                 .setup = alc262_toshiba_s06_setup,
12814                 .init_hook = alc_inithook,
12815         },
12816         [ALC262_TOSHIBA_RX1] = {
12817                 .mixers = { alc262_toshiba_rx1_mixer },
12818                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12819                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12820                 .dac_nids = alc262_dac_nids,
12821                 .hp_nid = 0x03,
12822                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12823                 .channel_mode = alc262_modes,
12824                 .input_mux = &alc262_capture_source,
12825                 .unsol_event = alc262_hippo_unsol_event,
12826                 .setup = alc262_hippo_setup,
12827                 .init_hook = alc262_hippo_automute,
12828         },
12829         [ALC262_TYAN] = {
12830                 .mixers = { alc262_tyan_mixer },
12831                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
12832                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12833                 .dac_nids = alc262_dac_nids,
12834                 .hp_nid = 0x02,
12835                 .dig_out_nid = ALC262_DIGOUT_NID,
12836                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12837                 .channel_mode = alc262_modes,
12838                 .input_mux = &alc262_capture_source,
12839                 .unsol_event = alc_automute_amp_unsol_event,
12840                 .setup = alc262_tyan_setup,
12841                 .init_hook = alc_automute_amp,
12842         },
12843 };
12844
12845 static int patch_alc262(struct hda_codec *codec)
12846 {
12847         struct alc_spec *spec;
12848         int board_config;
12849         int err;
12850
12851         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12852         if (spec == NULL)
12853                 return -ENOMEM;
12854
12855         codec->spec = spec;
12856 #if 0
12857         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
12858          * under-run
12859          */
12860         {
12861         int tmp;
12862         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12863         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
12864         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12865         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
12866         }
12867 #endif
12868         alc_auto_parse_customize_define(codec);
12869
12870         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
12871
12872         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
12873                                                   alc262_models,
12874                                                   alc262_cfg_tbl);
12875
12876         if (board_config < 0) {
12877                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12878                        codec->chip_name);
12879                 board_config = ALC262_AUTO;
12880         }
12881
12882         if (board_config == ALC262_AUTO)
12883                 alc_pick_fixup(codec, alc262_fixup_tbl, alc262_fixups, 1);
12884
12885         if (board_config == ALC262_AUTO) {
12886                 /* automatic parse from the BIOS config */
12887                 err = alc262_parse_auto_config(codec);
12888                 if (err < 0) {
12889                         alc_free(codec);
12890                         return err;
12891                 } else if (!err) {
12892                         printk(KERN_INFO
12893                                "hda_codec: Cannot set up configuration "
12894                                "from BIOS.  Using base mode...\n");
12895                         board_config = ALC262_BASIC;
12896                 }
12897         }
12898
12899         if (!spec->no_analog && has_cdefine_beep(codec)) {
12900                 err = snd_hda_attach_beep_device(codec, 0x1);
12901                 if (err < 0) {
12902                         alc_free(codec);
12903                         return err;
12904                 }
12905         }
12906
12907         if (board_config != ALC262_AUTO)
12908                 setup_preset(codec, &alc262_presets[board_config]);
12909
12910         spec->stream_analog_playback = &alc262_pcm_analog_playback;
12911         spec->stream_analog_capture = &alc262_pcm_analog_capture;
12912
12913         spec->stream_digital_playback = &alc262_pcm_digital_playback;
12914         spec->stream_digital_capture = &alc262_pcm_digital_capture;
12915
12916         if (!spec->adc_nids && spec->input_mux) {
12917                 int i;
12918                 /* check whether the digital-mic has to be supported */
12919                 for (i = 0; i < spec->input_mux->num_items; i++) {
12920                         if (spec->input_mux->items[i].index >= 9)
12921                                 break;
12922                 }
12923                 if (i < spec->input_mux->num_items) {
12924                         /* use only ADC0 */
12925                         spec->adc_nids = alc262_dmic_adc_nids;
12926                         spec->num_adc_nids = 1;
12927                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
12928                 } else {
12929                         /* all analog inputs */
12930                         /* check whether NID 0x07 is valid */
12931                         unsigned int wcap = get_wcaps(codec, 0x07);
12932
12933                         /* get type */
12934                         wcap = get_wcaps_type(wcap);
12935                         if (wcap != AC_WID_AUD_IN) {
12936                                 spec->adc_nids = alc262_adc_nids_alt;
12937                                 spec->num_adc_nids =
12938                                         ARRAY_SIZE(alc262_adc_nids_alt);
12939                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
12940                         } else {
12941                                 spec->adc_nids = alc262_adc_nids;
12942                                 spec->num_adc_nids =
12943                                         ARRAY_SIZE(alc262_adc_nids);
12944                                 spec->capsrc_nids = alc262_capsrc_nids;
12945                         }
12946                 }
12947         }
12948         if (!spec->cap_mixer && !spec->no_analog)
12949                 set_capture_mixer(codec);
12950         if (!spec->no_analog && has_cdefine_beep(codec))
12951                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12952
12953         if (board_config == ALC262_AUTO)
12954                 alc_pick_fixup(codec, alc262_fixup_tbl, alc262_fixups, 0);
12955
12956         spec->vmaster_nid = 0x0c;
12957
12958         codec->patch_ops = alc_patch_ops;
12959         if (board_config == ALC262_AUTO)
12960                 spec->init_hook = alc262_auto_init;
12961
12962         alc_init_jacks(codec);
12963 #ifdef CONFIG_SND_HDA_POWER_SAVE
12964         if (!spec->loopback.amplist)
12965                 spec->loopback.amplist = alc262_loopbacks;
12966 #endif
12967
12968         return 0;
12969 }
12970
12971 /*
12972  *  ALC268 channel source setting (2 channel)
12973  */
12974 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
12975 #define alc268_modes            alc260_modes
12976
12977 static hda_nid_t alc268_dac_nids[2] = {
12978         /* front, hp */
12979         0x02, 0x03
12980 };
12981
12982 static hda_nid_t alc268_adc_nids[2] = {
12983         /* ADC0-1 */
12984         0x08, 0x07
12985 };
12986
12987 static hda_nid_t alc268_adc_nids_alt[1] = {
12988         /* ADC0 */
12989         0x08
12990 };
12991
12992 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
12993
12994 static struct snd_kcontrol_new alc268_base_mixer[] = {
12995         /* output mixer control */
12996         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12997         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12998         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12999         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13000         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13001         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13002         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13003         { }
13004 };
13005
13006 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
13007         /* output mixer control */
13008         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13009         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13010         ALC262_HIPPO_MASTER_SWITCH,
13011         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13012         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13013         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13014         { }
13015 };
13016
13017 /* bind Beep switches of both NID 0x0f and 0x10 */
13018 static struct hda_bind_ctls alc268_bind_beep_sw = {
13019         .ops = &snd_hda_bind_sw,
13020         .values = {
13021                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
13022                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
13023                 0
13024         },
13025 };
13026
13027 static struct snd_kcontrol_new alc268_beep_mixer[] = {
13028         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
13029         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
13030         { }
13031 };
13032
13033 static struct hda_verb alc268_eapd_verbs[] = {
13034         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13035         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13036         { }
13037 };
13038
13039 /* Toshiba specific */
13040 static struct hda_verb alc268_toshiba_verbs[] = {
13041         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13042         { } /* end */
13043 };
13044
13045 /* Acer specific */
13046 /* bind volumes of both NID 0x02 and 0x03 */
13047 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
13048         .ops = &snd_hda_bind_vol,
13049         .values = {
13050                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
13051                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
13052                 0
13053         },
13054 };
13055
13056 /* mute/unmute internal speaker according to the hp jack and mute state */
13057 static void alc268_acer_automute(struct hda_codec *codec, int force)
13058 {
13059         struct alc_spec *spec = codec->spec;
13060         unsigned int mute;
13061
13062         if (force || !spec->sense_updated) {
13063                 spec->jack_present = snd_hda_jack_detect(codec, 0x14);
13064                 spec->sense_updated = 1;
13065         }
13066         if (spec->jack_present)
13067                 mute = HDA_AMP_MUTE; /* mute internal speaker */
13068         else /* unmute internal speaker if necessary */
13069                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
13070         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
13071                                  HDA_AMP_MUTE, mute);
13072 }
13073
13074
13075 /* bind hp and internal speaker mute (with plug check) */
13076 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
13077                                      struct snd_ctl_elem_value *ucontrol)
13078 {
13079         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
13080         long *valp = ucontrol->value.integer.value;
13081         int change;
13082
13083         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
13084         if (change)
13085                 alc268_acer_automute(codec, 0);
13086         return change;
13087 }
13088
13089 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
13090         /* output mixer control */
13091         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13092         {
13093                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13094                 .name = "Master Playback Switch",
13095                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13096                 .info = snd_hda_mixer_amp_switch_info,
13097                 .get = snd_hda_mixer_amp_switch_get,
13098                 .put = alc268_acer_master_sw_put,
13099                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13100         },
13101         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
13102         { }
13103 };
13104
13105 static struct snd_kcontrol_new alc268_acer_mixer[] = {
13106         /* output mixer control */
13107         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13108         {
13109                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13110                 .name = "Master Playback Switch",
13111                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13112                 .info = snd_hda_mixer_amp_switch_info,
13113                 .get = snd_hda_mixer_amp_switch_get,
13114                 .put = alc268_acer_master_sw_put,
13115                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13116         },
13117         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13118         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13119         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13120         { }
13121 };
13122
13123 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
13124         /* output mixer control */
13125         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13126         {
13127                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13128                 .name = "Master Playback Switch",
13129                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13130                 .info = snd_hda_mixer_amp_switch_info,
13131                 .get = snd_hda_mixer_amp_switch_get,
13132                 .put = alc268_acer_master_sw_put,
13133                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13134         },
13135         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13136         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13137         { }
13138 };
13139
13140 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
13141         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13142         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13143         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13144         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13145         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
13146         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
13147         { }
13148 };
13149
13150 static struct hda_verb alc268_acer_verbs[] = {
13151         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
13152         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13153         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13154         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13155         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13156         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13157         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13158         { }
13159 };
13160
13161 /* unsolicited event for HP jack sensing */
13162 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
13163 #define alc268_toshiba_setup            alc262_hippo_setup
13164 #define alc268_toshiba_automute         alc262_hippo_automute
13165
13166 static void alc268_acer_unsol_event(struct hda_codec *codec,
13167                                        unsigned int res)
13168 {
13169         if ((res >> 26) != ALC880_HP_EVENT)
13170                 return;
13171         alc268_acer_automute(codec, 1);
13172 }
13173
13174 static void alc268_acer_init_hook(struct hda_codec *codec)
13175 {
13176         alc268_acer_automute(codec, 1);
13177 }
13178
13179 /* toggle speaker-output according to the hp-jack state */
13180 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
13181 {
13182         unsigned int present;
13183         unsigned char bits;
13184
13185         present = snd_hda_jack_detect(codec, 0x15);
13186         bits = present ? HDA_AMP_MUTE : 0;
13187         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
13188                                  HDA_AMP_MUTE, bits);
13189         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
13190                                  HDA_AMP_MUTE, bits);
13191 }
13192
13193 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
13194                                     unsigned int res)
13195 {
13196         switch (res >> 26) {
13197         case ALC880_HP_EVENT:
13198                 alc268_aspire_one_speaker_automute(codec);
13199                 break;
13200         case ALC880_MIC_EVENT:
13201                 alc_mic_automute(codec);
13202                 break;
13203         }
13204 }
13205
13206 static void alc268_acer_lc_setup(struct hda_codec *codec)
13207 {
13208         struct alc_spec *spec = codec->spec;
13209         spec->ext_mic.pin = 0x18;
13210         spec->ext_mic.mux_idx = 0;
13211         spec->int_mic.pin = 0x12;
13212         spec->int_mic.mux_idx = 6;
13213         spec->auto_mic = 1;
13214 }
13215
13216 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
13217 {
13218         alc268_aspire_one_speaker_automute(codec);
13219         alc_mic_automute(codec);
13220 }
13221
13222 static struct snd_kcontrol_new alc268_dell_mixer[] = {
13223         /* output mixer control */
13224         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13225         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13226         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13227         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13228         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13229         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13230         { }
13231 };
13232
13233 static struct hda_verb alc268_dell_verbs[] = {
13234         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13235         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13236         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13237         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13238         { }
13239 };
13240
13241 /* mute/unmute internal speaker according to the hp jack and mute state */
13242 static void alc268_dell_setup(struct hda_codec *codec)
13243 {
13244         struct alc_spec *spec = codec->spec;
13245
13246         spec->autocfg.hp_pins[0] = 0x15;
13247         spec->autocfg.speaker_pins[0] = 0x14;
13248         spec->ext_mic.pin = 0x18;
13249         spec->ext_mic.mux_idx = 0;
13250         spec->int_mic.pin = 0x19;
13251         spec->int_mic.mux_idx = 1;
13252         spec->auto_mic = 1;
13253 }
13254
13255 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
13256         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13257         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13258         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13259         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13260         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13261         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
13262         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
13263         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
13264         { }
13265 };
13266
13267 static struct hda_verb alc267_quanta_il1_verbs[] = {
13268         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13269         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13270         { }
13271 };
13272
13273 static void alc267_quanta_il1_setup(struct hda_codec *codec)
13274 {
13275         struct alc_spec *spec = codec->spec;
13276         spec->autocfg.hp_pins[0] = 0x15;
13277         spec->autocfg.speaker_pins[0] = 0x14;
13278         spec->ext_mic.pin = 0x18;
13279         spec->ext_mic.mux_idx = 0;
13280         spec->int_mic.pin = 0x19;
13281         spec->int_mic.mux_idx = 1;
13282         spec->auto_mic = 1;
13283 }
13284
13285 /*
13286  * generic initialization of ADC, input mixers and output mixers
13287  */
13288 static struct hda_verb alc268_base_init_verbs[] = {
13289         /* Unmute DAC0-1 and set vol = 0 */
13290         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13291         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13292
13293         /*
13294          * Set up output mixers (0x0c - 0x0e)
13295          */
13296         /* set vol=0 to output mixers */
13297         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13298         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
13299
13300         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13301         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13302
13303         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13304         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
13305         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13306         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13307         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13308         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13309         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13310         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13311
13312         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13313         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13314         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13315         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13316         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13317
13318         /* set PCBEEP vol = 0, mute connections */
13319         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13320         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13321         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13322
13323         /* Unmute Selector 23h,24h and set the default input to mic-in */
13324
13325         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13326         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13327         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
13328         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13329
13330         { }
13331 };
13332
13333 /*
13334  * generic initialization of ADC, input mixers and output mixers
13335  */
13336 static struct hda_verb alc268_volume_init_verbs[] = {
13337         /* set output DAC */
13338         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13339         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13340
13341         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13342         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13343         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13344         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13345         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13346
13347         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13348         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13349         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13350
13351         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13352         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13353
13354         /* set PCBEEP vol = 0, mute connections */
13355         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13356         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13357         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13358
13359         { }
13360 };
13361
13362 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
13363         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13364         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13365         { } /* end */
13366 };
13367
13368 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
13369         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13370         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13371         _DEFINE_CAPSRC(1),
13372         { } /* end */
13373 };
13374
13375 static struct snd_kcontrol_new alc268_capture_mixer[] = {
13376         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13377         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13378         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
13379         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
13380         _DEFINE_CAPSRC(2),
13381         { } /* end */
13382 };
13383
13384 static struct hda_input_mux alc268_capture_source = {
13385         .num_items = 4,
13386         .items = {
13387                 { "Mic", 0x0 },
13388                 { "Front Mic", 0x1 },
13389                 { "Line", 0x2 },
13390                 { "CD", 0x3 },
13391         },
13392 };
13393
13394 static struct hda_input_mux alc268_acer_capture_source = {
13395         .num_items = 3,
13396         .items = {
13397                 { "Mic", 0x0 },
13398                 { "Internal Mic", 0x1 },
13399                 { "Line", 0x2 },
13400         },
13401 };
13402
13403 static struct hda_input_mux alc268_acer_dmic_capture_source = {
13404         .num_items = 3,
13405         .items = {
13406                 { "Mic", 0x0 },
13407                 { "Internal Mic", 0x6 },
13408                 { "Line", 0x2 },
13409         },
13410 };
13411
13412 #ifdef CONFIG_SND_DEBUG
13413 static struct snd_kcontrol_new alc268_test_mixer[] = {
13414         /* Volume widgets */
13415         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13416         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13417         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13418         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
13419         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
13420         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
13421         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
13422         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
13423         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
13424         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
13425         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
13426         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
13427         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
13428         /* The below appears problematic on some hardwares */
13429         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
13430         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13431         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
13432         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
13433         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
13434
13435         /* Modes for retasking pin widgets */
13436         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
13437         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
13438         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
13439         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
13440
13441         /* Controls for GPIO pins, assuming they are configured as outputs */
13442         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
13443         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
13444         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
13445         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
13446
13447         /* Switches to allow the digital SPDIF output pin to be enabled.
13448          * The ALC268 does not have an SPDIF input.
13449          */
13450         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
13451
13452         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
13453          * this output to turn on an external amplifier.
13454          */
13455         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
13456         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
13457
13458         { } /* end */
13459 };
13460 #endif
13461
13462 /* create input playback/capture controls for the given pin */
13463 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
13464                                     const char *ctlname, int idx)
13465 {
13466         hda_nid_t dac;
13467         int err;
13468
13469         switch (nid) {
13470         case 0x14:
13471         case 0x16:
13472                 dac = 0x02;
13473                 break;
13474         case 0x15:
13475         case 0x1a: /* ALC259/269 only */
13476         case 0x1b: /* ALC259/269 only */
13477         case 0x21: /* ALC269vb has this pin, too */
13478                 dac = 0x03;
13479                 break;
13480         default:
13481                 snd_printd(KERN_WARNING "hda_codec: "
13482                            "ignoring pin 0x%x as unknown\n", nid);
13483                 return 0;
13484         }
13485         if (spec->multiout.dac_nids[0] != dac &&
13486             spec->multiout.dac_nids[1] != dac) {
13487                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
13488                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
13489                                                       HDA_OUTPUT));
13490                 if (err < 0)
13491                         return err;
13492                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
13493         }
13494
13495         if (nid != 0x16)
13496                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13497                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
13498         else /* mono */
13499                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13500                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
13501         if (err < 0)
13502                 return err;
13503         return 0;
13504 }
13505
13506 /* add playback controls from the parsed DAC table */
13507 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
13508                                              const struct auto_pin_cfg *cfg)
13509 {
13510         hda_nid_t nid;
13511         int err;
13512
13513         spec->multiout.dac_nids = spec->private_dac_nids;
13514
13515         nid = cfg->line_out_pins[0];
13516         if (nid) {
13517                 const char *name;
13518                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
13519                         name = "Speaker";
13520                 else
13521                         name = "Front";
13522                 err = alc268_new_analog_output(spec, nid, name, 0);
13523                 if (err < 0)
13524                         return err;
13525         }
13526
13527         nid = cfg->speaker_pins[0];
13528         if (nid == 0x1d) {
13529                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
13530                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
13531                 if (err < 0)
13532                         return err;
13533         } else if (nid) {
13534                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
13535                 if (err < 0)
13536                         return err;
13537         }
13538         nid = cfg->hp_pins[0];
13539         if (nid) {
13540                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
13541                 if (err < 0)
13542                         return err;
13543         }
13544
13545         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
13546         if (nid == 0x16) {
13547                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
13548                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
13549                 if (err < 0)
13550                         return err;
13551         }
13552         return 0;
13553 }
13554
13555 /* create playback/capture controls for input pins */
13556 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
13557                                                 const struct auto_pin_cfg *cfg)
13558 {
13559         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
13560 }
13561
13562 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
13563                                               hda_nid_t nid, int pin_type)
13564 {
13565         int idx;
13566
13567         alc_set_pin_output(codec, nid, pin_type);
13568         if (nid == 0x14 || nid == 0x16)
13569                 idx = 0;
13570         else
13571                 idx = 1;
13572         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
13573 }
13574
13575 static void alc268_auto_init_multi_out(struct hda_codec *codec)
13576 {
13577         struct alc_spec *spec = codec->spec;
13578         int i;
13579
13580         for (i = 0; i < spec->autocfg.line_outs; i++) {
13581                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13582                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13583                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
13584         }
13585 }
13586
13587 static void alc268_auto_init_hp_out(struct hda_codec *codec)
13588 {
13589         struct alc_spec *spec = codec->spec;
13590         hda_nid_t pin;
13591         int i;
13592
13593         for (i = 0; i < spec->autocfg.hp_outs; i++) {
13594                 pin = spec->autocfg.hp_pins[i];
13595                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
13596         }
13597         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
13598                 pin = spec->autocfg.speaker_pins[i];
13599                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
13600         }
13601         if (spec->autocfg.mono_out_pin)
13602                 snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0,
13603                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13604 }
13605
13606 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
13607 {
13608         struct alc_spec *spec = codec->spec;
13609         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
13610         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
13611         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
13612         unsigned int    dac_vol1, dac_vol2;
13613
13614         if (line_nid == 0x1d || speaker_nid == 0x1d) {
13615                 snd_hda_codec_write(codec, speaker_nid, 0,
13616                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13617                 /* mute mixer inputs from 0x1d */
13618                 snd_hda_codec_write(codec, 0x0f, 0,
13619                                     AC_VERB_SET_AMP_GAIN_MUTE,
13620                                     AMP_IN_UNMUTE(1));
13621                 snd_hda_codec_write(codec, 0x10, 0,
13622                                     AC_VERB_SET_AMP_GAIN_MUTE,
13623                                     AMP_IN_UNMUTE(1));
13624         } else {
13625                 /* unmute mixer inputs from 0x1d */
13626                 snd_hda_codec_write(codec, 0x0f, 0,
13627                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13628                 snd_hda_codec_write(codec, 0x10, 0,
13629                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13630         }
13631
13632         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
13633         if (line_nid == 0x14)
13634                 dac_vol2 = AMP_OUT_ZERO;
13635         else if (line_nid == 0x15)
13636                 dac_vol1 = AMP_OUT_ZERO;
13637         if (hp_nid == 0x14)
13638                 dac_vol2 = AMP_OUT_ZERO;
13639         else if (hp_nid == 0x15)
13640                 dac_vol1 = AMP_OUT_ZERO;
13641         if (line_nid != 0x16 || hp_nid != 0x16 ||
13642             spec->autocfg.line_out_pins[1] != 0x16 ||
13643             spec->autocfg.line_out_pins[2] != 0x16)
13644                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
13645
13646         snd_hda_codec_write(codec, 0x02, 0,
13647                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
13648         snd_hda_codec_write(codec, 0x03, 0,
13649                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
13650 }
13651
13652 /* pcm configuration: identical with ALC880 */
13653 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
13654 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
13655 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
13656 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
13657
13658 /*
13659  * BIOS auto configuration
13660  */
13661 static int alc268_parse_auto_config(struct hda_codec *codec)
13662 {
13663         struct alc_spec *spec = codec->spec;
13664         int err;
13665         static hda_nid_t alc268_ignore[] = { 0 };
13666
13667         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13668                                            alc268_ignore);
13669         if (err < 0)
13670                 return err;
13671         if (!spec->autocfg.line_outs) {
13672                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13673                         spec->multiout.max_channels = 2;
13674                         spec->no_analog = 1;
13675                         goto dig_only;
13676                 }
13677                 return 0; /* can't find valid BIOS pin config */
13678         }
13679         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13680         if (err < 0)
13681                 return err;
13682         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13683         if (err < 0)
13684                 return err;
13685
13686         spec->multiout.max_channels = 2;
13687
13688  dig_only:
13689         /* digital only support output */
13690         alc_auto_parse_digital(codec);
13691         if (spec->kctls.list)
13692                 add_mixer(spec, spec->kctls.list);
13693
13694         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13695                 add_mixer(spec, alc268_beep_mixer);
13696
13697         add_verb(spec, alc268_volume_init_verbs);
13698         spec->num_mux_defs = 2;
13699         spec->input_mux = &spec->private_imux[0];
13700
13701         err = alc_auto_add_mic_boost(codec);
13702         if (err < 0)
13703                 return err;
13704
13705         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13706
13707         return 1;
13708 }
13709
13710 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
13711
13712 /* init callback for auto-configuration model -- overriding the default init */
13713 static void alc268_auto_init(struct hda_codec *codec)
13714 {
13715         struct alc_spec *spec = codec->spec;
13716         alc268_auto_init_multi_out(codec);
13717         alc268_auto_init_hp_out(codec);
13718         alc268_auto_init_mono_speaker_out(codec);
13719         alc268_auto_init_analog_input(codec);
13720         alc_auto_init_digital(codec);
13721         if (spec->unsol_event)
13722                 alc_inithook(codec);
13723 }
13724
13725 /*
13726  * configuration and preset
13727  */
13728 static const char *alc268_models[ALC268_MODEL_LAST] = {
13729         [ALC267_QUANTA_IL1]     = "quanta-il1",
13730         [ALC268_3ST]            = "3stack",
13731         [ALC268_TOSHIBA]        = "toshiba",
13732         [ALC268_ACER]           = "acer",
13733         [ALC268_ACER_DMIC]      = "acer-dmic",
13734         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
13735         [ALC268_DELL]           = "dell",
13736         [ALC268_ZEPTO]          = "zepto",
13737 #ifdef CONFIG_SND_DEBUG
13738         [ALC268_TEST]           = "test",
13739 #endif
13740         [ALC268_AUTO]           = "auto",
13741 };
13742
13743 static struct snd_pci_quirk alc268_cfg_tbl[] = {
13744         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13745         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13746         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13747         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13748         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13749         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13750                                                 ALC268_ACER_ASPIRE_ONE),
13751         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13752         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13753                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13754         /* almost compatible with toshiba but with optional digital outs;
13755          * auto-probing seems working fine
13756          */
13757         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13758                            ALC268_AUTO),
13759         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13760         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13761         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13762         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13763         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13764         {}
13765 };
13766
13767 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
13768 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13769         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13770         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13771         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13772                            ALC268_TOSHIBA),
13773         {}
13774 };
13775
13776 static struct alc_config_preset alc268_presets[] = {
13777         [ALC267_QUANTA_IL1] = {
13778                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13779                             alc268_capture_nosrc_mixer },
13780                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13781                                 alc267_quanta_il1_verbs },
13782                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13783                 .dac_nids = alc268_dac_nids,
13784                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13785                 .adc_nids = alc268_adc_nids_alt,
13786                 .hp_nid = 0x03,
13787                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13788                 .channel_mode = alc268_modes,
13789                 .unsol_event = alc_sku_unsol_event,
13790                 .setup = alc267_quanta_il1_setup,
13791                 .init_hook = alc_inithook,
13792         },
13793         [ALC268_3ST] = {
13794                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13795                             alc268_beep_mixer },
13796                 .init_verbs = { alc268_base_init_verbs },
13797                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13798                 .dac_nids = alc268_dac_nids,
13799                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13800                 .adc_nids = alc268_adc_nids_alt,
13801                 .capsrc_nids = alc268_capsrc_nids,
13802                 .hp_nid = 0x03,
13803                 .dig_out_nid = ALC268_DIGOUT_NID,
13804                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13805                 .channel_mode = alc268_modes,
13806                 .input_mux = &alc268_capture_source,
13807         },
13808         [ALC268_TOSHIBA] = {
13809                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13810                             alc268_beep_mixer },
13811                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13812                                 alc268_toshiba_verbs },
13813                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13814                 .dac_nids = alc268_dac_nids,
13815                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13816                 .adc_nids = alc268_adc_nids_alt,
13817                 .capsrc_nids = alc268_capsrc_nids,
13818                 .hp_nid = 0x03,
13819                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13820                 .channel_mode = alc268_modes,
13821                 .input_mux = &alc268_capture_source,
13822                 .unsol_event = alc268_toshiba_unsol_event,
13823                 .setup = alc268_toshiba_setup,
13824                 .init_hook = alc268_toshiba_automute,
13825         },
13826         [ALC268_ACER] = {
13827                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13828                             alc268_beep_mixer },
13829                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13830                                 alc268_acer_verbs },
13831                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13832                 .dac_nids = alc268_dac_nids,
13833                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13834                 .adc_nids = alc268_adc_nids_alt,
13835                 .capsrc_nids = alc268_capsrc_nids,
13836                 .hp_nid = 0x02,
13837                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13838                 .channel_mode = alc268_modes,
13839                 .input_mux = &alc268_acer_capture_source,
13840                 .unsol_event = alc268_acer_unsol_event,
13841                 .init_hook = alc268_acer_init_hook,
13842         },
13843         [ALC268_ACER_DMIC] = {
13844                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13845                             alc268_beep_mixer },
13846                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13847                                 alc268_acer_verbs },
13848                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13849                 .dac_nids = alc268_dac_nids,
13850                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13851                 .adc_nids = alc268_adc_nids_alt,
13852                 .capsrc_nids = alc268_capsrc_nids,
13853                 .hp_nid = 0x02,
13854                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13855                 .channel_mode = alc268_modes,
13856                 .input_mux = &alc268_acer_dmic_capture_source,
13857                 .unsol_event = alc268_acer_unsol_event,
13858                 .init_hook = alc268_acer_init_hook,
13859         },
13860         [ALC268_ACER_ASPIRE_ONE] = {
13861                 .mixers = { alc268_acer_aspire_one_mixer,
13862                             alc268_beep_mixer,
13863                             alc268_capture_nosrc_mixer },
13864                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13865                                 alc268_acer_aspire_one_verbs },
13866                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13867                 .dac_nids = alc268_dac_nids,
13868                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13869                 .adc_nids = alc268_adc_nids_alt,
13870                 .capsrc_nids = alc268_capsrc_nids,
13871                 .hp_nid = 0x03,
13872                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13873                 .channel_mode = alc268_modes,
13874                 .unsol_event = alc268_acer_lc_unsol_event,
13875                 .setup = alc268_acer_lc_setup,
13876                 .init_hook = alc268_acer_lc_init_hook,
13877         },
13878         [ALC268_DELL] = {
13879                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
13880                             alc268_capture_nosrc_mixer },
13881                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13882                                 alc268_dell_verbs },
13883                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13884                 .dac_nids = alc268_dac_nids,
13885                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13886                 .adc_nids = alc268_adc_nids_alt,
13887                 .capsrc_nids = alc268_capsrc_nids,
13888                 .hp_nid = 0x02,
13889                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13890                 .channel_mode = alc268_modes,
13891                 .unsol_event = alc_sku_unsol_event,
13892                 .setup = alc268_dell_setup,
13893                 .init_hook = alc_inithook,
13894         },
13895         [ALC268_ZEPTO] = {
13896                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13897                             alc268_beep_mixer },
13898                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13899                                 alc268_toshiba_verbs },
13900                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13901                 .dac_nids = alc268_dac_nids,
13902                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13903                 .adc_nids = alc268_adc_nids_alt,
13904                 .capsrc_nids = alc268_capsrc_nids,
13905                 .hp_nid = 0x03,
13906                 .dig_out_nid = ALC268_DIGOUT_NID,
13907                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13908                 .channel_mode = alc268_modes,
13909                 .input_mux = &alc268_capture_source,
13910                 .setup = alc268_toshiba_setup,
13911                 .init_hook = alc268_toshiba_automute,
13912         },
13913 #ifdef CONFIG_SND_DEBUG
13914         [ALC268_TEST] = {
13915                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
13916                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13917                                 alc268_volume_init_verbs },
13918                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13919                 .dac_nids = alc268_dac_nids,
13920                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13921                 .adc_nids = alc268_adc_nids_alt,
13922                 .capsrc_nids = alc268_capsrc_nids,
13923                 .hp_nid = 0x03,
13924                 .dig_out_nid = ALC268_DIGOUT_NID,
13925                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13926                 .channel_mode = alc268_modes,
13927                 .input_mux = &alc268_capture_source,
13928         },
13929 #endif
13930 };
13931
13932 static int patch_alc268(struct hda_codec *codec)
13933 {
13934         struct alc_spec *spec;
13935         int board_config;
13936         int i, has_beep, err;
13937
13938         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13939         if (spec == NULL)
13940                 return -ENOMEM;
13941
13942         codec->spec = spec;
13943
13944         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
13945                                                   alc268_models,
13946                                                   alc268_cfg_tbl);
13947
13948         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
13949                 board_config = snd_hda_check_board_codec_sid_config(codec,
13950                         ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
13951
13952         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
13953                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13954                        codec->chip_name);
13955                 board_config = ALC268_AUTO;
13956         }
13957
13958         if (board_config == ALC268_AUTO) {
13959                 /* automatic parse from the BIOS config */
13960                 err = alc268_parse_auto_config(codec);
13961                 if (err < 0) {
13962                         alc_free(codec);
13963                         return err;
13964                 } else if (!err) {
13965                         printk(KERN_INFO
13966                                "hda_codec: Cannot set up configuration "
13967                                "from BIOS.  Using base mode...\n");
13968                         board_config = ALC268_3ST;
13969                 }
13970         }
13971
13972         if (board_config != ALC268_AUTO)
13973                 setup_preset(codec, &alc268_presets[board_config]);
13974
13975         spec->stream_analog_playback = &alc268_pcm_analog_playback;
13976         spec->stream_analog_capture = &alc268_pcm_analog_capture;
13977         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
13978
13979         spec->stream_digital_playback = &alc268_pcm_digital_playback;
13980
13981         has_beep = 0;
13982         for (i = 0; i < spec->num_mixers; i++) {
13983                 if (spec->mixers[i] == alc268_beep_mixer) {
13984                         has_beep = 1;
13985                         break;
13986                 }
13987         }
13988
13989         if (has_beep) {
13990                 err = snd_hda_attach_beep_device(codec, 0x1);
13991                 if (err < 0) {
13992                         alc_free(codec);
13993                         return err;
13994                 }
13995                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
13996                         /* override the amp caps for beep generator */
13997                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
13998                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
13999                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
14000                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
14001                                           (0 << AC_AMPCAP_MUTE_SHIFT));
14002         }
14003
14004         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
14005                 /* check whether NID 0x07 is valid */
14006                 unsigned int wcap = get_wcaps(codec, 0x07);
14007                 int i;
14008
14009                 spec->capsrc_nids = alc268_capsrc_nids;
14010                 /* get type */
14011                 wcap = get_wcaps_type(wcap);
14012                 if (spec->auto_mic ||
14013                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
14014                         spec->adc_nids = alc268_adc_nids_alt;
14015                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
14016                         if (spec->auto_mic)
14017                                 fixup_automic_adc(codec);
14018                         if (spec->auto_mic || spec->input_mux->num_items == 1)
14019                                 add_mixer(spec, alc268_capture_nosrc_mixer);
14020                         else
14021                                 add_mixer(spec, alc268_capture_alt_mixer);
14022                 } else {
14023                         spec->adc_nids = alc268_adc_nids;
14024                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
14025                         add_mixer(spec, alc268_capture_mixer);
14026                 }
14027                 /* set default input source */
14028                 for (i = 0; i < spec->num_adc_nids; i++)
14029                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
14030                                 0, AC_VERB_SET_CONNECT_SEL,
14031                                 i < spec->num_mux_defs ?
14032                                 spec->input_mux[i].items[0].index :
14033                                 spec->input_mux->items[0].index);
14034         }
14035
14036         spec->vmaster_nid = 0x02;
14037
14038         codec->patch_ops = alc_patch_ops;
14039         if (board_config == ALC268_AUTO)
14040                 spec->init_hook = alc268_auto_init;
14041
14042         alc_init_jacks(codec);
14043
14044         return 0;
14045 }
14046
14047 /*
14048  *  ALC269 channel source setting (2 channel)
14049  */
14050 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
14051
14052 #define alc269_dac_nids         alc260_dac_nids
14053
14054 static hda_nid_t alc269_adc_nids[1] = {
14055         /* ADC1 */
14056         0x08,
14057 };
14058
14059 static hda_nid_t alc269_capsrc_nids[1] = {
14060         0x23,
14061 };
14062
14063 static hda_nid_t alc269vb_adc_nids[1] = {
14064         /* ADC1 */
14065         0x09,
14066 };
14067
14068 static hda_nid_t alc269vb_capsrc_nids[1] = {
14069         0x22,
14070 };
14071
14072 static hda_nid_t alc269_adc_candidates[] = {
14073         0x08, 0x09, 0x07,
14074 };
14075
14076 #define alc269_modes            alc260_modes
14077 #define alc269_capture_source   alc880_lg_lw_capture_source
14078
14079 static struct snd_kcontrol_new alc269_base_mixer[] = {
14080         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14081         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14082         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14083         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14084         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14085         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14086         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14087         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14088         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14089         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14090         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14091         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
14092         { } /* end */
14093 };
14094
14095 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
14096         /* output mixer control */
14097         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14098         {
14099                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14100                 .name = "Master Playback Switch",
14101                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14102                 .info = snd_hda_mixer_amp_switch_info,
14103                 .get = snd_hda_mixer_amp_switch_get,
14104                 .put = alc268_acer_master_sw_put,
14105                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14106         },
14107         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14108         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14109         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14110         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14111         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14112         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
14113         { }
14114 };
14115
14116 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
14117         /* output mixer control */
14118         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14119         {
14120                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14121                 .name = "Master Playback Switch",
14122                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14123                 .info = snd_hda_mixer_amp_switch_info,
14124                 .get = snd_hda_mixer_amp_switch_get,
14125                 .put = alc268_acer_master_sw_put,
14126                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14127         },
14128         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14129         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14130         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14131         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14132         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14133         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
14134         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
14135         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
14136         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
14137         { }
14138 };
14139
14140 static struct snd_kcontrol_new alc269_laptop_mixer[] = {
14141         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14142         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14143         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14144         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14145         { } /* end */
14146 };
14147
14148 static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
14149         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14150         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14151         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14152         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14153         { } /* end */
14154 };
14155
14156 static struct snd_kcontrol_new alc269_asus_mixer[] = {
14157         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14158         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
14159         { } /* end */
14160 };
14161
14162 /* capture mixer elements */
14163 static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
14164         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14165         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14166         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14167         HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
14168         { } /* end */
14169 };
14170
14171 static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
14172         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14173         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14174         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14175         { } /* end */
14176 };
14177
14178 static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
14179         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14180         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14181         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14182         HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
14183         { } /* end */
14184 };
14185
14186 static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
14187         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14188         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14189         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14190         { } /* end */
14191 };
14192
14193 /* FSC amilo */
14194 #define alc269_fujitsu_mixer    alc269_laptop_mixer
14195
14196 static struct hda_verb alc269_quanta_fl1_verbs[] = {
14197         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14198         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14199         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14200         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14201         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14202         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14203         { }
14204 };
14205
14206 static struct hda_verb alc269_lifebook_verbs[] = {
14207         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14208         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
14209         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14210         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14211         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14212         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14213         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14214         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14215         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14216         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14217         { }
14218 };
14219
14220 /* toggle speaker-output according to the hp-jack state */
14221 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
14222 {
14223         unsigned int present;
14224         unsigned char bits;
14225
14226         present = snd_hda_jack_detect(codec, 0x15);
14227         bits = present ? HDA_AMP_MUTE : 0;
14228         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14229                                  HDA_AMP_MUTE, bits);
14230         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14231                                  HDA_AMP_MUTE, bits);
14232
14233         snd_hda_codec_write(codec, 0x20, 0,
14234                         AC_VERB_SET_COEF_INDEX, 0x0c);
14235         snd_hda_codec_write(codec, 0x20, 0,
14236                         AC_VERB_SET_PROC_COEF, 0x680);
14237
14238         snd_hda_codec_write(codec, 0x20, 0,
14239                         AC_VERB_SET_COEF_INDEX, 0x0c);
14240         snd_hda_codec_write(codec, 0x20, 0,
14241                         AC_VERB_SET_PROC_COEF, 0x480);
14242 }
14243
14244 /* toggle speaker-output according to the hp-jacks state */
14245 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
14246 {
14247         unsigned int present;
14248         unsigned char bits;
14249
14250         /* Check laptop headphone socket */
14251         present = snd_hda_jack_detect(codec, 0x15);
14252
14253         /* Check port replicator headphone socket */
14254         present |= snd_hda_jack_detect(codec, 0x1a);
14255
14256         bits = present ? HDA_AMP_MUTE : 0;
14257         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14258                                  HDA_AMP_MUTE, bits);
14259         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14260                                  HDA_AMP_MUTE, bits);
14261
14262         snd_hda_codec_write(codec, 0x20, 0,
14263                         AC_VERB_SET_COEF_INDEX, 0x0c);
14264         snd_hda_codec_write(codec, 0x20, 0,
14265                         AC_VERB_SET_PROC_COEF, 0x680);
14266
14267         snd_hda_codec_write(codec, 0x20, 0,
14268                         AC_VERB_SET_COEF_INDEX, 0x0c);
14269         snd_hda_codec_write(codec, 0x20, 0,
14270                         AC_VERB_SET_PROC_COEF, 0x480);
14271 }
14272
14273 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
14274 {
14275         unsigned int present_laptop;
14276         unsigned int present_dock;
14277
14278         present_laptop  = snd_hda_jack_detect(codec, 0x18);
14279         present_dock    = snd_hda_jack_detect(codec, 0x1b);
14280
14281         /* Laptop mic port overrides dock mic port, design decision */
14282         if (present_dock)
14283                 snd_hda_codec_write(codec, 0x23, 0,
14284                                 AC_VERB_SET_CONNECT_SEL, 0x3);
14285         if (present_laptop)
14286                 snd_hda_codec_write(codec, 0x23, 0,
14287                                 AC_VERB_SET_CONNECT_SEL, 0x0);
14288         if (!present_dock && !present_laptop)
14289                 snd_hda_codec_write(codec, 0x23, 0,
14290                                 AC_VERB_SET_CONNECT_SEL, 0x1);
14291 }
14292
14293 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
14294                                     unsigned int res)
14295 {
14296         switch (res >> 26) {
14297         case ALC880_HP_EVENT:
14298                 alc269_quanta_fl1_speaker_automute(codec);
14299                 break;
14300         case ALC880_MIC_EVENT:
14301                 alc_mic_automute(codec);
14302                 break;
14303         }
14304 }
14305
14306 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
14307                                         unsigned int res)
14308 {
14309         if ((res >> 26) == ALC880_HP_EVENT)
14310                 alc269_lifebook_speaker_automute(codec);
14311         if ((res >> 26) == ALC880_MIC_EVENT)
14312                 alc269_lifebook_mic_autoswitch(codec);
14313 }
14314
14315 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
14316 {
14317         struct alc_spec *spec = codec->spec;
14318         spec->autocfg.hp_pins[0] = 0x15;
14319         spec->autocfg.speaker_pins[0] = 0x14;
14320         spec->ext_mic.pin = 0x18;
14321         spec->ext_mic.mux_idx = 0;
14322         spec->int_mic.pin = 0x19;
14323         spec->int_mic.mux_idx = 1;
14324         spec->auto_mic = 1;
14325 }
14326
14327 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
14328 {
14329         alc269_quanta_fl1_speaker_automute(codec);
14330         alc_mic_automute(codec);
14331 }
14332
14333 static void alc269_lifebook_init_hook(struct hda_codec *codec)
14334 {
14335         alc269_lifebook_speaker_automute(codec);
14336         alc269_lifebook_mic_autoswitch(codec);
14337 }
14338
14339 static struct hda_verb alc269_laptop_dmic_init_verbs[] = {
14340         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14341         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
14342         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14343         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14344         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14345         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14346         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14347         {}
14348 };
14349
14350 static struct hda_verb alc269_laptop_amic_init_verbs[] = {
14351         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14352         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
14353         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14354         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
14355         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14356         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14357         {}
14358 };
14359
14360 static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
14361         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14362         {0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
14363         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14364         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14365         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14366         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14367         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14368         {}
14369 };
14370
14371 static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
14372         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14373         {0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
14374         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14375         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14376         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14377         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14378         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14379         {}
14380 };
14381
14382 static struct hda_verb alc271_acer_dmic_verbs[] = {
14383         {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14384         {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14385         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14386         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14387         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14388         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14389         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
14390         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14391         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14392         {0x22, AC_VERB_SET_CONNECT_SEL, 6},
14393         { }
14394 };
14395
14396 /* toggle speaker-output according to the hp-jack state */
14397 static void alc269_speaker_automute(struct hda_codec *codec)
14398 {
14399         struct alc_spec *spec = codec->spec;
14400         unsigned int nid = spec->autocfg.hp_pins[0];
14401         unsigned int present;
14402         unsigned char bits;
14403
14404         present = snd_hda_jack_detect(codec, nid);
14405         bits = present ? HDA_AMP_MUTE : 0;
14406         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14407                                  HDA_AMP_MUTE, bits);
14408         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14409                                  HDA_AMP_MUTE, bits);
14410         alc_report_jack(codec, nid);
14411 }
14412
14413 /* unsolicited event for HP jack sensing */
14414 static void alc269_laptop_unsol_event(struct hda_codec *codec,
14415                                      unsigned int res)
14416 {
14417         switch (res >> 26) {
14418         case ALC880_HP_EVENT:
14419                 alc269_speaker_automute(codec);
14420                 break;
14421         case ALC880_MIC_EVENT:
14422                 alc_mic_automute(codec);
14423                 break;
14424         }
14425 }
14426
14427 static void alc269_laptop_amic_setup(struct hda_codec *codec)
14428 {
14429         struct alc_spec *spec = codec->spec;
14430         spec->autocfg.hp_pins[0] = 0x15;
14431         spec->autocfg.speaker_pins[0] = 0x14;
14432         spec->ext_mic.pin = 0x18;
14433         spec->ext_mic.mux_idx = 0;
14434         spec->int_mic.pin = 0x19;
14435         spec->int_mic.mux_idx = 1;
14436         spec->auto_mic = 1;
14437 }
14438
14439 static void alc269_laptop_dmic_setup(struct hda_codec *codec)
14440 {
14441         struct alc_spec *spec = codec->spec;
14442         spec->autocfg.hp_pins[0] = 0x15;
14443         spec->autocfg.speaker_pins[0] = 0x14;
14444         spec->ext_mic.pin = 0x18;
14445         spec->ext_mic.mux_idx = 0;
14446         spec->int_mic.pin = 0x12;
14447         spec->int_mic.mux_idx = 5;
14448         spec->auto_mic = 1;
14449 }
14450
14451 static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
14452 {
14453         struct alc_spec *spec = codec->spec;
14454         spec->autocfg.hp_pins[0] = 0x21;
14455         spec->autocfg.speaker_pins[0] = 0x14;
14456         spec->ext_mic.pin = 0x18;
14457         spec->ext_mic.mux_idx = 0;
14458         spec->int_mic.pin = 0x19;
14459         spec->int_mic.mux_idx = 1;
14460         spec->auto_mic = 1;
14461 }
14462
14463 static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
14464 {
14465         struct alc_spec *spec = codec->spec;
14466         spec->autocfg.hp_pins[0] = 0x21;
14467         spec->autocfg.speaker_pins[0] = 0x14;
14468         spec->ext_mic.pin = 0x18;
14469         spec->ext_mic.mux_idx = 0;
14470         spec->int_mic.pin = 0x12;
14471         spec->int_mic.mux_idx = 6;
14472         spec->auto_mic = 1;
14473 }
14474
14475 static void alc269_laptop_inithook(struct hda_codec *codec)
14476 {
14477         alc269_speaker_automute(codec);
14478         alc_mic_automute(codec);
14479 }
14480
14481 /*
14482  * generic initialization of ADC, input mixers and output mixers
14483  */
14484 static struct hda_verb alc269_init_verbs[] = {
14485         /*
14486          * Unmute ADC0 and set the default input to mic-in
14487          */
14488         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14489
14490         /*
14491          * Set up output mixers (0x02 - 0x03)
14492          */
14493         /* set vol=0 to output mixers */
14494         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14495         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14496
14497         /* set up input amps for analog loopback */
14498         /* Amp Indices: DAC = 0, mixer = 1 */
14499         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14500         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14501         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14502         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14503         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14504         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14505
14506         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14507         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14508         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14509         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14510         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14511         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14512         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14513
14514         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14515         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14516
14517         /* FIXME: use Mux-type input source selection */
14518         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14519         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14520         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
14521
14522         /* set EAPD */
14523         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14524         { }
14525 };
14526
14527 static struct hda_verb alc269vb_init_verbs[] = {
14528         /*
14529          * Unmute ADC0 and set the default input to mic-in
14530          */
14531         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14532
14533         /*
14534          * Set up output mixers (0x02 - 0x03)
14535          */
14536         /* set vol=0 to output mixers */
14537         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14538         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14539
14540         /* set up input amps for analog loopback */
14541         /* Amp Indices: DAC = 0, mixer = 1 */
14542         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14543         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14544         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14545         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14546         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14547         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14548
14549         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14550         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14551         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14552         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14553         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14554         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14555         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14556
14557         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14558         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14559
14560         /* FIXME: use Mux-type input source selection */
14561         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14562         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14563         {0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
14564
14565         /* set EAPD */
14566         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14567         { }
14568 };
14569
14570 #define alc269_auto_create_multi_out_ctls \
14571         alc268_auto_create_multi_out_ctls
14572 #define alc269_auto_create_input_ctls \
14573         alc268_auto_create_input_ctls
14574
14575 #ifdef CONFIG_SND_HDA_POWER_SAVE
14576 #define alc269_loopbacks        alc880_loopbacks
14577 #endif
14578
14579 /* pcm configuration: identical with ALC880 */
14580 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
14581 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
14582 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
14583 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
14584
14585 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
14586         .substreams = 1,
14587         .channels_min = 2,
14588         .channels_max = 8,
14589         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14590         /* NID is set in alc_build_pcms */
14591         .ops = {
14592                 .open = alc880_playback_pcm_open,
14593                 .prepare = alc880_playback_pcm_prepare,
14594                 .cleanup = alc880_playback_pcm_cleanup
14595         },
14596 };
14597
14598 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
14599         .substreams = 1,
14600         .channels_min = 2,
14601         .channels_max = 2,
14602         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14603         /* NID is set in alc_build_pcms */
14604 };
14605
14606 #ifdef CONFIG_SND_HDA_POWER_SAVE
14607 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
14608 {
14609         switch (codec->subsystem_id) {
14610         case 0x103c1586:
14611                 return 1;
14612         }
14613         return 0;
14614 }
14615
14616 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
14617 {
14618         /* update mute-LED according to the speaker mute state */
14619         if (nid == 0x01 || nid == 0x14) {
14620                 int pinval;
14621                 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
14622                     HDA_AMP_MUTE)
14623                         pinval = 0x24;
14624                 else
14625                         pinval = 0x20;
14626                 /* mic2 vref pin is used for mute LED control */
14627                 snd_hda_codec_update_cache(codec, 0x19, 0,
14628                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
14629                                            pinval);
14630         }
14631         return alc_check_power_status(codec, nid);
14632 }
14633 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14634
14635 static int alc275_setup_dual_adc(struct hda_codec *codec)
14636 {
14637         struct alc_spec *spec = codec->spec;
14638
14639         if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
14640                 return 0;
14641         if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
14642             (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
14643                 if (spec->ext_mic.pin <= 0x12) {
14644                         spec->private_adc_nids[0] = 0x08;
14645                         spec->private_adc_nids[1] = 0x11;
14646                         spec->private_capsrc_nids[0] = 0x23;
14647                         spec->private_capsrc_nids[1] = 0x22;
14648                 } else {
14649                         spec->private_adc_nids[0] = 0x11;
14650                         spec->private_adc_nids[1] = 0x08;
14651                         spec->private_capsrc_nids[0] = 0x22;
14652                         spec->private_capsrc_nids[1] = 0x23;
14653                 }
14654                 spec->adc_nids = spec->private_adc_nids;
14655                 spec->capsrc_nids = spec->private_capsrc_nids;
14656                 spec->num_adc_nids = 2;
14657                 spec->dual_adc_switch = 1;
14658                 snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
14659                             spec->adc_nids[0], spec->adc_nids[1]);
14660                 return 1;
14661         }
14662         return 0;
14663 }
14664
14665 /* different alc269-variants */
14666 enum {
14667         ALC269_TYPE_NORMAL,
14668         ALC269_TYPE_ALC258,
14669         ALC269_TYPE_ALC259,
14670         ALC269_TYPE_ALC269VB,
14671         ALC269_TYPE_ALC270,
14672         ALC269_TYPE_ALC271X,
14673 };
14674
14675 /*
14676  * BIOS auto configuration
14677  */
14678 static int alc269_parse_auto_config(struct hda_codec *codec)
14679 {
14680         struct alc_spec *spec = codec->spec;
14681         int err;
14682         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
14683
14684         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14685                                            alc269_ignore);
14686         if (err < 0)
14687                 return err;
14688
14689         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
14690         if (err < 0)
14691                 return err;
14692         if (spec->codec_variant == ALC269_TYPE_NORMAL)
14693                 err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
14694         else
14695                 err = alc_auto_create_input_ctls(codec, &spec->autocfg, 0,
14696                                                  0x22, 0);
14697         if (err < 0)
14698                 return err;
14699
14700         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14701
14702         alc_auto_parse_digital(codec);
14703
14704         if (spec->kctls.list)
14705                 add_mixer(spec, spec->kctls.list);
14706
14707         if (spec->codec_variant != ALC269_TYPE_NORMAL) {
14708                 add_verb(spec, alc269vb_init_verbs);
14709                 alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
14710         } else {
14711                 add_verb(spec, alc269_init_verbs);
14712                 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
14713         }
14714
14715         spec->num_mux_defs = 1;
14716         spec->input_mux = &spec->private_imux[0];
14717
14718         if (!alc275_setup_dual_adc(codec))
14719                 fillup_priv_adc_nids(codec, alc269_adc_candidates,
14720                                      sizeof(alc269_adc_candidates));
14721
14722         /* set default input source */
14723         if (!spec->dual_adc_switch)
14724                 select_or_unmute_capsrc(codec, spec->capsrc_nids[0],
14725                                         spec->input_mux->items[0].index);
14726
14727         err = alc_auto_add_mic_boost(codec);
14728         if (err < 0)
14729                 return err;
14730
14731         if (!spec->cap_mixer && !spec->no_analog)
14732                 set_capture_mixer(codec);
14733
14734         return 1;
14735 }
14736
14737 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
14738 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
14739 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
14740
14741
14742 /* init callback for auto-configuration model -- overriding the default init */
14743 static void alc269_auto_init(struct hda_codec *codec)
14744 {
14745         struct alc_spec *spec = codec->spec;
14746         alc269_auto_init_multi_out(codec);
14747         alc269_auto_init_hp_out(codec);
14748         alc269_auto_init_analog_input(codec);
14749         alc_auto_init_digital(codec);
14750         if (spec->unsol_event)
14751                 alc_inithook(codec);
14752 }
14753
14754 #ifdef SND_HDA_NEEDS_RESUME
14755 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
14756 {
14757         int val = alc_read_coef_idx(codec, 0x04);
14758         if (power_up)
14759                 val |= 1 << 11;
14760         else
14761                 val &= ~(1 << 11);
14762         alc_write_coef_idx(codec, 0x04, val);
14763 }
14764
14765 #ifdef CONFIG_SND_HDA_POWER_SAVE
14766 static int alc269_suspend(struct hda_codec *codec, pm_message_t state)
14767 {
14768         struct alc_spec *spec = codec->spec;
14769
14770         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
14771                 alc269_toggle_power_output(codec, 0);
14772         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14773                 alc269_toggle_power_output(codec, 0);
14774                 msleep(150);
14775         }
14776
14777         alc_shutup(codec);
14778         if (spec && spec->power_hook)
14779                 spec->power_hook(codec);
14780         return 0;
14781 }
14782 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14783
14784 static int alc269_resume(struct hda_codec *codec)
14785 {
14786         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14787                 alc269_toggle_power_output(codec, 0);
14788                 msleep(150);
14789         }
14790
14791         codec->patch_ops.init(codec);
14792
14793         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14794                 alc269_toggle_power_output(codec, 1);
14795                 msleep(200);
14796         }
14797
14798         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
14799                 alc269_toggle_power_output(codec, 1);
14800
14801         snd_hda_codec_resume_amp(codec);
14802         snd_hda_codec_resume_cache(codec);
14803         hda_call_check_power_status(codec, 0x01);
14804         return 0;
14805 }
14806 #endif /* SND_HDA_NEEDS_RESUME */
14807
14808 enum {
14809         ALC269_FIXUP_SONY_VAIO,
14810         ALC269_FIXUP_DELL_M101Z,
14811 };
14812
14813 static const struct alc_fixup alc269_fixups[] = {
14814         [ALC269_FIXUP_SONY_VAIO] = {
14815                 .verbs = (const struct hda_verb[]) {
14816                         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14817                         {}
14818                 }
14819         },
14820         [ALC269_FIXUP_DELL_M101Z] = {
14821                 .verbs = (const struct hda_verb[]) {
14822                         /* Enables internal speaker */
14823                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
14824                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
14825                         {}
14826                 }
14827         },
14828 };
14829
14830 static struct snd_pci_quirk alc269_fixup_tbl[] = {
14831         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14832         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
14833         {}
14834 };
14835
14836
14837 /*
14838  * configuration and preset
14839  */
14840 static const char *alc269_models[ALC269_MODEL_LAST] = {
14841         [ALC269_BASIC]                  = "basic",
14842         [ALC269_QUANTA_FL1]             = "quanta",
14843         [ALC269_AMIC]                   = "laptop-amic",
14844         [ALC269_DMIC]                   = "laptop-dmic",
14845         [ALC269_FUJITSU]                = "fujitsu",
14846         [ALC269_LIFEBOOK]               = "lifebook",
14847         [ALC269_AUTO]                   = "auto",
14848 };
14849
14850 static struct snd_pci_quirk alc269_cfg_tbl[] = {
14851         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
14852         SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
14853         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
14854                       ALC269_AMIC),
14855         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
14856         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
14857         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
14858         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
14859         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
14860         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
14861         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
14862         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
14863         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
14864         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_AMIC),
14865         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
14866         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
14867         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
14868         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
14869         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
14870         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
14871         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
14872         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
14873         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
14874         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
14875         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
14876         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
14877         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
14878         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
14879         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
14880         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
14881         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
14882         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
14883         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
14884         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
14885         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
14886         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
14887         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
14888         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
14889         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
14890         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
14891         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
14892                       ALC269_DMIC),
14893         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
14894                       ALC269_DMIC),
14895         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
14896         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
14897         SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
14898         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
14899         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
14900         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
14901         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
14902         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
14903         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
14904         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
14905         {}
14906 };
14907
14908 static struct alc_config_preset alc269_presets[] = {
14909         [ALC269_BASIC] = {
14910                 .mixers = { alc269_base_mixer },
14911                 .init_verbs = { alc269_init_verbs },
14912                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14913                 .dac_nids = alc269_dac_nids,
14914                 .hp_nid = 0x03,
14915                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14916                 .channel_mode = alc269_modes,
14917                 .input_mux = &alc269_capture_source,
14918         },
14919         [ALC269_QUANTA_FL1] = {
14920                 .mixers = { alc269_quanta_fl1_mixer },
14921                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
14922                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14923                 .dac_nids = alc269_dac_nids,
14924                 .hp_nid = 0x03,
14925                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14926                 .channel_mode = alc269_modes,
14927                 .input_mux = &alc269_capture_source,
14928                 .unsol_event = alc269_quanta_fl1_unsol_event,
14929                 .setup = alc269_quanta_fl1_setup,
14930                 .init_hook = alc269_quanta_fl1_init_hook,
14931         },
14932         [ALC269_AMIC] = {
14933                 .mixers = { alc269_laptop_mixer },
14934                 .cap_mixer = alc269_laptop_analog_capture_mixer,
14935                 .init_verbs = { alc269_init_verbs,
14936                                 alc269_laptop_amic_init_verbs },
14937                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14938                 .dac_nids = alc269_dac_nids,
14939                 .hp_nid = 0x03,
14940                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14941                 .channel_mode = alc269_modes,
14942                 .unsol_event = alc269_laptop_unsol_event,
14943                 .setup = alc269_laptop_amic_setup,
14944                 .init_hook = alc269_laptop_inithook,
14945         },
14946         [ALC269_DMIC] = {
14947                 .mixers = { alc269_laptop_mixer },
14948                 .cap_mixer = alc269_laptop_digital_capture_mixer,
14949                 .init_verbs = { alc269_init_verbs,
14950                                 alc269_laptop_dmic_init_verbs },
14951                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14952                 .dac_nids = alc269_dac_nids,
14953                 .hp_nid = 0x03,
14954                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14955                 .channel_mode = alc269_modes,
14956                 .unsol_event = alc269_laptop_unsol_event,
14957                 .setup = alc269_laptop_dmic_setup,
14958                 .init_hook = alc269_laptop_inithook,
14959         },
14960         [ALC269VB_AMIC] = {
14961                 .mixers = { alc269vb_laptop_mixer },
14962                 .cap_mixer = alc269vb_laptop_analog_capture_mixer,
14963                 .init_verbs = { alc269vb_init_verbs,
14964                                 alc269vb_laptop_amic_init_verbs },
14965                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14966                 .dac_nids = alc269_dac_nids,
14967                 .hp_nid = 0x03,
14968                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14969                 .channel_mode = alc269_modes,
14970                 .unsol_event = alc269_laptop_unsol_event,
14971                 .setup = alc269vb_laptop_amic_setup,
14972                 .init_hook = alc269_laptop_inithook,
14973         },
14974         [ALC269VB_DMIC] = {
14975                 .mixers = { alc269vb_laptop_mixer },
14976                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
14977                 .init_verbs = { alc269vb_init_verbs,
14978                                 alc269vb_laptop_dmic_init_verbs },
14979                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14980                 .dac_nids = alc269_dac_nids,
14981                 .hp_nid = 0x03,
14982                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14983                 .channel_mode = alc269_modes,
14984                 .unsol_event = alc269_laptop_unsol_event,
14985                 .setup = alc269vb_laptop_dmic_setup,
14986                 .init_hook = alc269_laptop_inithook,
14987         },
14988         [ALC269_FUJITSU] = {
14989                 .mixers = { alc269_fujitsu_mixer },
14990                 .cap_mixer = alc269_laptop_digital_capture_mixer,
14991                 .init_verbs = { alc269_init_verbs,
14992                                 alc269_laptop_dmic_init_verbs },
14993                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14994                 .dac_nids = alc269_dac_nids,
14995                 .hp_nid = 0x03,
14996                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14997                 .channel_mode = alc269_modes,
14998                 .unsol_event = alc269_laptop_unsol_event,
14999                 .setup = alc269_laptop_dmic_setup,
15000                 .init_hook = alc269_laptop_inithook,
15001         },
15002         [ALC269_LIFEBOOK] = {
15003                 .mixers = { alc269_lifebook_mixer },
15004                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
15005                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15006                 .dac_nids = alc269_dac_nids,
15007                 .hp_nid = 0x03,
15008                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15009                 .channel_mode = alc269_modes,
15010                 .input_mux = &alc269_capture_source,
15011                 .unsol_event = alc269_lifebook_unsol_event,
15012                 .init_hook = alc269_lifebook_init_hook,
15013         },
15014         [ALC271_ACER] = {
15015                 .mixers = { alc269_asus_mixer },
15016                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
15017                 .init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
15018                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15019                 .dac_nids = alc269_dac_nids,
15020                 .adc_nids = alc262_dmic_adc_nids,
15021                 .num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
15022                 .capsrc_nids = alc262_dmic_capsrc_nids,
15023                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15024                 .channel_mode = alc269_modes,
15025                 .input_mux = &alc269_capture_source,
15026                 .dig_out_nid = ALC880_DIGOUT_NID,
15027                 .unsol_event = alc_sku_unsol_event,
15028                 .setup = alc269vb_laptop_dmic_setup,
15029                 .init_hook = alc_inithook,
15030         },
15031 };
15032
15033 static int alc269_fill_coef(struct hda_codec *codec)
15034 {
15035         int val;
15036
15037         if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
15038                 alc_write_coef_idx(codec, 0xf, 0x960b);
15039                 alc_write_coef_idx(codec, 0xe, 0x8817);
15040         }
15041
15042         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
15043                 alc_write_coef_idx(codec, 0xf, 0x960b);
15044                 alc_write_coef_idx(codec, 0xe, 0x8814);
15045         }
15046
15047         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
15048                 val = alc_read_coef_idx(codec, 0x04);
15049                 /* Power up output pin */
15050                 alc_write_coef_idx(codec, 0x04, val | (1<<11));
15051         }
15052
15053         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
15054                 val = alc_read_coef_idx(codec, 0xd);
15055                 if ((val & 0x0c00) >> 10 != 0x1) {
15056                         /* Capless ramp up clock control */
15057                         alc_write_coef_idx(codec, 0xd, val | 1<<10);
15058                 }
15059                 val = alc_read_coef_idx(codec, 0x17);
15060                 if ((val & 0x01c0) >> 6 != 0x4) {
15061                         /* Class D power on reset */
15062                         alc_write_coef_idx(codec, 0x17, val | 1<<7);
15063                 }
15064         }
15065         return 0;
15066 }
15067
15068 static int patch_alc269(struct hda_codec *codec)
15069 {
15070         struct alc_spec *spec;
15071         int board_config, coef;
15072         int err;
15073
15074         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15075         if (spec == NULL)
15076                 return -ENOMEM;
15077
15078         codec->spec = spec;
15079
15080         alc_auto_parse_customize_define(codec);
15081
15082         coef = alc_read_coef_idx(codec, 0);
15083         if ((coef & 0x00f0) == 0x0010) {
15084                 if (codec->bus->pci->subsystem_vendor == 0x1025 &&
15085                     spec->cdefine.platform_type == 1) {
15086                         alc_codec_rename(codec, "ALC271X");
15087                         spec->codec_variant = ALC269_TYPE_ALC271X;
15088                 } else if ((coef & 0xf000) == 0x1000) {
15089                         spec->codec_variant = ALC269_TYPE_ALC270;
15090                 } else if ((coef & 0xf000) == 0x2000) {
15091                         alc_codec_rename(codec, "ALC259");
15092                         spec->codec_variant = ALC269_TYPE_ALC259;
15093                 } else if ((coef & 0xf000) == 0x3000) {
15094                         alc_codec_rename(codec, "ALC258");
15095                         spec->codec_variant = ALC269_TYPE_ALC258;
15096                 } else {
15097                         alc_codec_rename(codec, "ALC269VB");
15098                         spec->codec_variant = ALC269_TYPE_ALC269VB;
15099                 }
15100         } else
15101                 alc_fix_pll_init(codec, 0x20, 0x04, 15);
15102
15103         alc269_fill_coef(codec);
15104
15105         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
15106                                                   alc269_models,
15107                                                   alc269_cfg_tbl);
15108
15109         if (board_config < 0) {
15110                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15111                        codec->chip_name);
15112                 board_config = ALC269_AUTO;
15113         }
15114
15115         if (board_config == ALC269_AUTO)
15116                 alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 1);
15117
15118         if (board_config == ALC269_AUTO) {
15119                 /* automatic parse from the BIOS config */
15120                 err = alc269_parse_auto_config(codec);
15121                 if (err < 0) {
15122                         alc_free(codec);
15123                         return err;
15124                 } else if (!err) {
15125                         printk(KERN_INFO
15126                                "hda_codec: Cannot set up configuration "
15127                                "from BIOS.  Using base mode...\n");
15128                         board_config = ALC269_BASIC;
15129                 }
15130         }
15131
15132         if (has_cdefine_beep(codec)) {
15133                 err = snd_hda_attach_beep_device(codec, 0x1);
15134                 if (err < 0) {
15135                         alc_free(codec);
15136                         return err;
15137                 }
15138         }
15139
15140         if (board_config != ALC269_AUTO)
15141                 setup_preset(codec, &alc269_presets[board_config]);
15142
15143         if (board_config == ALC269_QUANTA_FL1) {
15144                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
15145                  * fix the sample rate of analog I/O to 44.1kHz
15146                  */
15147                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
15148                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
15149         } else if (spec->dual_adc_switch) {
15150                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15151                 /* switch ADC dynamically */
15152                 spec->stream_analog_capture = &dualmic_pcm_analog_capture;
15153         } else {
15154                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15155                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
15156         }
15157         spec->stream_digital_playback = &alc269_pcm_digital_playback;
15158         spec->stream_digital_capture = &alc269_pcm_digital_capture;
15159
15160         if (!spec->adc_nids) { /* wasn't filled automatically? use default */
15161                 if (spec->codec_variant == ALC269_TYPE_NORMAL) {
15162                         spec->adc_nids = alc269_adc_nids;
15163                         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
15164                         spec->capsrc_nids = alc269_capsrc_nids;
15165                 } else {
15166                         spec->adc_nids = alc269vb_adc_nids;
15167                         spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
15168                         spec->capsrc_nids = alc269vb_capsrc_nids;
15169                 }
15170         }
15171
15172         if (!spec->cap_mixer)
15173                 set_capture_mixer(codec);
15174         if (has_cdefine_beep(codec))
15175                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
15176
15177         if (board_config == ALC269_AUTO)
15178                 alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 0);
15179
15180         spec->vmaster_nid = 0x02;
15181
15182         codec->patch_ops = alc_patch_ops;
15183 #ifdef CONFIG_SND_HDA_POWER_SAVE
15184         codec->patch_ops.suspend = alc269_suspend;
15185 #endif
15186 #ifdef SND_HDA_NEEDS_RESUME
15187         codec->patch_ops.resume = alc269_resume;
15188 #endif
15189         if (board_config == ALC269_AUTO)
15190                 spec->init_hook = alc269_auto_init;
15191
15192         alc_init_jacks(codec);
15193 #ifdef CONFIG_SND_HDA_POWER_SAVE
15194         if (!spec->loopback.amplist)
15195                 spec->loopback.amplist = alc269_loopbacks;
15196         if (alc269_mic2_for_mute_led(codec))
15197                 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
15198 #endif
15199
15200         return 0;
15201 }
15202
15203 /*
15204  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
15205  */
15206
15207 /*
15208  * set the path ways for 2 channel output
15209  * need to set the codec line out and mic 1 pin widgets to inputs
15210  */
15211 static struct hda_verb alc861_threestack_ch2_init[] = {
15212         /* set pin widget 1Ah (line in) for input */
15213         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15214         /* set pin widget 18h (mic1/2) for input, for mic also enable
15215          * the vref
15216          */
15217         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15218
15219         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15220 #if 0
15221         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15222         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15223 #endif
15224         { } /* end */
15225 };
15226 /*
15227  * 6ch mode
15228  * need to set the codec line out and mic 1 pin widgets to outputs
15229  */
15230 static struct hda_verb alc861_threestack_ch6_init[] = {
15231         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15232         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15233         /* set pin widget 18h (mic1) for output (CLFE)*/
15234         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15235
15236         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15237         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15238
15239         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15240 #if 0
15241         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15242         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15243 #endif
15244         { } /* end */
15245 };
15246
15247 static struct hda_channel_mode alc861_threestack_modes[2] = {
15248         { 2, alc861_threestack_ch2_init },
15249         { 6, alc861_threestack_ch6_init },
15250 };
15251 /* Set mic1 as input and unmute the mixer */
15252 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
15253         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15254         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15255         { } /* end */
15256 };
15257 /* Set mic1 as output and mute mixer */
15258 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
15259         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15260         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15261         { } /* end */
15262 };
15263
15264 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
15265         { 2, alc861_uniwill_m31_ch2_init },
15266         { 4, alc861_uniwill_m31_ch4_init },
15267 };
15268
15269 /* Set mic1 and line-in as input and unmute the mixer */
15270 static struct hda_verb alc861_asus_ch2_init[] = {
15271         /* set pin widget 1Ah (line in) for input */
15272         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15273         /* set pin widget 18h (mic1/2) for input, for mic also enable
15274          * the vref
15275          */
15276         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15277
15278         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15279 #if 0
15280         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15281         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15282 #endif
15283         { } /* end */
15284 };
15285 /* Set mic1 nad line-in as output and mute mixer */
15286 static struct hda_verb alc861_asus_ch6_init[] = {
15287         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15288         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15289         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15290         /* set pin widget 18h (mic1) for output (CLFE)*/
15291         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15292         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15293         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15294         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15295
15296         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15297 #if 0
15298         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15299         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15300 #endif
15301         { } /* end */
15302 };
15303
15304 static struct hda_channel_mode alc861_asus_modes[2] = {
15305         { 2, alc861_asus_ch2_init },
15306         { 6, alc861_asus_ch6_init },
15307 };
15308
15309 /* patch-ALC861 */
15310
15311 static struct snd_kcontrol_new alc861_base_mixer[] = {
15312         /* output mixer control */
15313         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15314         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15315         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15316         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15317         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15318
15319         /*Input mixer control */
15320         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15321            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15322         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15323         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15324         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15325         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15326         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15327         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15328         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15329         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15330
15331         { } /* end */
15332 };
15333
15334 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
15335         /* output mixer control */
15336         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15337         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15338         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15339         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15340         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15341
15342         /* Input mixer control */
15343         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15344            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15345         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15346         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15347         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15348         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15349         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15350         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15351         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15352         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15353
15354         {
15355                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15356                 .name = "Channel Mode",
15357                 .info = alc_ch_mode_info,
15358                 .get = alc_ch_mode_get,
15359                 .put = alc_ch_mode_put,
15360                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
15361         },
15362         { } /* end */
15363 };
15364
15365 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
15366         /* output mixer control */
15367         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15368         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15369         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15370
15371         { } /* end */
15372 };
15373
15374 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
15375         /* output mixer control */
15376         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15377         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15378         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15379         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15380         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15381
15382         /* Input mixer control */
15383         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15384            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15385         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15386         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15387         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15388         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15389         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15390         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15391         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15392         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15393
15394         {
15395                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15396                 .name = "Channel Mode",
15397                 .info = alc_ch_mode_info,
15398                 .get = alc_ch_mode_get,
15399                 .put = alc_ch_mode_put,
15400                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
15401         },
15402         { } /* end */
15403 };
15404
15405 static struct snd_kcontrol_new alc861_asus_mixer[] = {
15406         /* output mixer control */
15407         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15408         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15409         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15410         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15411         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15412
15413         /* Input mixer control */
15414         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15415         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15416         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15417         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15418         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15419         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15420         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15421         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15422         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15423         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
15424
15425         {
15426                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15427                 .name = "Channel Mode",
15428                 .info = alc_ch_mode_info,
15429                 .get = alc_ch_mode_get,
15430                 .put = alc_ch_mode_put,
15431                 .private_value = ARRAY_SIZE(alc861_asus_modes),
15432         },
15433         { }
15434 };
15435
15436 /* additional mixer */
15437 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
15438         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15439         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15440         { }
15441 };
15442
15443 /*
15444  * generic initialization of ADC, input mixers and output mixers
15445  */
15446 static struct hda_verb alc861_base_init_verbs[] = {
15447         /*
15448          * Unmute ADC0 and set the default input to mic-in
15449          */
15450         /* port-A for surround (rear panel) */
15451         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15452         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
15453         /* port-B for mic-in (rear panel) with vref */
15454         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15455         /* port-C for line-in (rear panel) */
15456         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15457         /* port-D for Front */
15458         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15459         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15460         /* port-E for HP out (front panel) */
15461         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15462         /* route front PCM to HP */
15463         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15464         /* port-F for mic-in (front panel) with vref */
15465         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15466         /* port-G for CLFE (rear panel) */
15467         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15468         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15469         /* port-H for side (rear panel) */
15470         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15471         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
15472         /* CD-in */
15473         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15474         /* route front mic to ADC1*/
15475         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15476         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15477
15478         /* Unmute DAC0~3 & spdif out*/
15479         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15480         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15481         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15482         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15483         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15484
15485         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15486         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15487         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15488         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15489         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15490
15491         /* Unmute Stereo Mixer 15 */
15492         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15493         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15494         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15495         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15496
15497         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15498         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15499         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15500         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15501         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15502         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15503         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15504         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15505         /* hp used DAC 3 (Front) */
15506         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15507         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15508
15509         { }
15510 };
15511
15512 static struct hda_verb alc861_threestack_init_verbs[] = {
15513         /*
15514          * Unmute ADC0 and set the default input to mic-in
15515          */
15516         /* port-A for surround (rear panel) */
15517         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15518         /* port-B for mic-in (rear panel) with vref */
15519         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15520         /* port-C for line-in (rear panel) */
15521         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15522         /* port-D for Front */
15523         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15524         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15525         /* port-E for HP out (front panel) */
15526         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15527         /* route front PCM to HP */
15528         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15529         /* port-F for mic-in (front panel) with vref */
15530         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15531         /* port-G for CLFE (rear panel) */
15532         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15533         /* port-H for side (rear panel) */
15534         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15535         /* CD-in */
15536         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15537         /* route front mic to ADC1*/
15538         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15539         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15540         /* Unmute DAC0~3 & spdif out*/
15541         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15542         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15543         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15544         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15545         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15546
15547         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15548         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15549         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15550         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15551         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15552
15553         /* Unmute Stereo Mixer 15 */
15554         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15555         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15556         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15557         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15558
15559         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15560         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15561         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15562         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15563         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15564         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15565         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15566         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15567         /* hp used DAC 3 (Front) */
15568         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15569         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15570         { }
15571 };
15572
15573 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
15574         /*
15575          * Unmute ADC0 and set the default input to mic-in
15576          */
15577         /* port-A for surround (rear panel) */
15578         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15579         /* port-B for mic-in (rear panel) with vref */
15580         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15581         /* port-C for line-in (rear panel) */
15582         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15583         /* port-D for Front */
15584         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15585         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15586         /* port-E for HP out (front panel) */
15587         /* this has to be set to VREF80 */
15588         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15589         /* route front PCM to HP */
15590         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15591         /* port-F for mic-in (front panel) with vref */
15592         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15593         /* port-G for CLFE (rear panel) */
15594         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15595         /* port-H for side (rear panel) */
15596         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15597         /* CD-in */
15598         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15599         /* route front mic to ADC1*/
15600         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15601         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15602         /* Unmute DAC0~3 & spdif out*/
15603         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15604         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15605         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15606         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15607         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15608
15609         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15610         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15611         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15612         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15613         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15614
15615         /* Unmute Stereo Mixer 15 */
15616         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15617         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15618         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15619         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15620
15621         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15622         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15623         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15624         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15625         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15626         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15627         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15628         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15629         /* hp used DAC 3 (Front) */
15630         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15631         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15632         { }
15633 };
15634
15635 static struct hda_verb alc861_asus_init_verbs[] = {
15636         /*
15637          * Unmute ADC0 and set the default input to mic-in
15638          */
15639         /* port-A for surround (rear panel)
15640          * according to codec#0 this is the HP jack
15641          */
15642         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
15643         /* route front PCM to HP */
15644         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
15645         /* port-B for mic-in (rear panel) with vref */
15646         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15647         /* port-C for line-in (rear panel) */
15648         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15649         /* port-D for Front */
15650         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15651         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15652         /* port-E for HP out (front panel) */
15653         /* this has to be set to VREF80 */
15654         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15655         /* route front PCM to HP */
15656         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15657         /* port-F for mic-in (front panel) with vref */
15658         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15659         /* port-G for CLFE (rear panel) */
15660         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15661         /* port-H for side (rear panel) */
15662         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15663         /* CD-in */
15664         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15665         /* route front mic to ADC1*/
15666         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15667         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15668         /* Unmute DAC0~3 & spdif out*/
15669         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15670         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15671         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15672         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15673         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15674         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15675         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15676         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15677         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15678         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15679
15680         /* Unmute Stereo Mixer 15 */
15681         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15682         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15683         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15684         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15685
15686         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15687         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15688         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15689         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15690         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15691         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15692         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15693         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15694         /* hp used DAC 3 (Front) */
15695         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15696         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15697         { }
15698 };
15699
15700 /* additional init verbs for ASUS laptops */
15701 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
15702         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
15703         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
15704         { }
15705 };
15706
15707 /*
15708  * generic initialization of ADC, input mixers and output mixers
15709  */
15710 static struct hda_verb alc861_auto_init_verbs[] = {
15711         /*
15712          * Unmute ADC0 and set the default input to mic-in
15713          */
15714         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
15715         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15716
15717         /* Unmute DAC0~3 & spdif out*/
15718         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15719         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15720         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15721         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15722         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15723
15724         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15725         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15726         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15727         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15728         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15729
15730         /* Unmute Stereo Mixer 15 */
15731         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15732         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15733         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15734         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
15735
15736         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15737         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15738         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15739         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15740         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15741         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15742         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15743         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15744
15745         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15746         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15747         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15748         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15749         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15750         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15751         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15752         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15753
15754         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
15755
15756         { }
15757 };
15758
15759 static struct hda_verb alc861_toshiba_init_verbs[] = {
15760         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15761
15762         { }
15763 };
15764
15765 /* toggle speaker-output according to the hp-jack state */
15766 static void alc861_toshiba_automute(struct hda_codec *codec)
15767 {
15768         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
15769
15770         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
15771                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
15772         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
15773                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
15774 }
15775
15776 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
15777                                        unsigned int res)
15778 {
15779         if ((res >> 26) == ALC880_HP_EVENT)
15780                 alc861_toshiba_automute(codec);
15781 }
15782
15783 /* pcm configuration: identical with ALC880 */
15784 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
15785 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
15786 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
15787 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
15788
15789
15790 #define ALC861_DIGOUT_NID       0x07
15791
15792 static struct hda_channel_mode alc861_8ch_modes[1] = {
15793         { 8, NULL }
15794 };
15795
15796 static hda_nid_t alc861_dac_nids[4] = {
15797         /* front, surround, clfe, side */
15798         0x03, 0x06, 0x05, 0x04
15799 };
15800
15801 static hda_nid_t alc660_dac_nids[3] = {
15802         /* front, clfe, surround */
15803         0x03, 0x05, 0x06
15804 };
15805
15806 static hda_nid_t alc861_adc_nids[1] = {
15807         /* ADC0-2 */
15808         0x08,
15809 };
15810
15811 static struct hda_input_mux alc861_capture_source = {
15812         .num_items = 5,
15813         .items = {
15814                 { "Mic", 0x0 },
15815                 { "Front Mic", 0x3 },
15816                 { "Line", 0x1 },
15817                 { "CD", 0x4 },
15818                 { "Mixer", 0x5 },
15819         },
15820 };
15821
15822 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
15823 {
15824         struct alc_spec *spec = codec->spec;
15825         hda_nid_t mix, srcs[5];
15826         int i, j, num;
15827
15828         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
15829                 return 0;
15830         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15831         if (num < 0)
15832                 return 0;
15833         for (i = 0; i < num; i++) {
15834                 unsigned int type;
15835                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
15836                 if (type != AC_WID_AUD_OUT)
15837                         continue;
15838                 for (j = 0; j < spec->multiout.num_dacs; j++)
15839                         if (spec->multiout.dac_nids[j] == srcs[i])
15840                                 break;
15841                 if (j >= spec->multiout.num_dacs)
15842                         return srcs[i];
15843         }
15844         return 0;
15845 }
15846
15847 /* fill in the dac_nids table from the parsed pin configuration */
15848 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
15849                                      const struct auto_pin_cfg *cfg)
15850 {
15851         struct alc_spec *spec = codec->spec;
15852         int i;
15853         hda_nid_t nid, dac;
15854
15855         spec->multiout.dac_nids = spec->private_dac_nids;
15856         for (i = 0; i < cfg->line_outs; i++) {
15857                 nid = cfg->line_out_pins[i];
15858                 dac = alc861_look_for_dac(codec, nid);
15859                 if (!dac)
15860                         continue;
15861                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
15862         }
15863         return 0;
15864 }
15865
15866 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
15867                                 hda_nid_t nid, unsigned int chs)
15868 {
15869         return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
15870                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
15871 }
15872
15873 /* add playback controls from the parsed DAC table */
15874 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
15875                                              const struct auto_pin_cfg *cfg)
15876 {
15877         struct alc_spec *spec = codec->spec;
15878         static const char *chname[4] = {
15879                 "Front", "Surround", NULL /*CLFE*/, "Side"
15880         };
15881         hda_nid_t nid;
15882         int i, err;
15883
15884         if (cfg->line_outs == 1) {
15885                 const char *pfx = NULL;
15886                 if (!cfg->hp_outs)
15887                         pfx = "Master";
15888                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
15889                         pfx = "Speaker";
15890                 if (pfx) {
15891                         nid = spec->multiout.dac_nids[0];
15892                         return alc861_create_out_sw(codec, pfx, nid, 3);
15893                 }
15894         }
15895
15896         for (i = 0; i < cfg->line_outs; i++) {
15897                 nid = spec->multiout.dac_nids[i];
15898                 if (!nid)
15899                         continue;
15900                 if (i == 2) {
15901                         /* Center/LFE */
15902                         err = alc861_create_out_sw(codec, "Center", nid, 1);
15903                         if (err < 0)
15904                                 return err;
15905                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
15906                         if (err < 0)
15907                                 return err;
15908                 } else {
15909                         err = alc861_create_out_sw(codec, chname[i], nid, 3);
15910                         if (err < 0)
15911                                 return err;
15912                 }
15913         }
15914         return 0;
15915 }
15916
15917 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
15918 {
15919         struct alc_spec *spec = codec->spec;
15920         int err;
15921         hda_nid_t nid;
15922
15923         if (!pin)
15924                 return 0;
15925
15926         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
15927                 nid = alc861_look_for_dac(codec, pin);
15928                 if (nid) {
15929                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
15930                         if (err < 0)
15931                                 return err;
15932                         spec->multiout.hp_nid = nid;
15933                 }
15934         }
15935         return 0;
15936 }
15937
15938 /* create playback/capture controls for input pins */
15939 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
15940                                                 const struct auto_pin_cfg *cfg)
15941 {
15942         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
15943 }
15944
15945 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
15946                                               hda_nid_t nid,
15947                                               int pin_type, hda_nid_t dac)
15948 {
15949         hda_nid_t mix, srcs[5];
15950         int i, num;
15951
15952         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
15953                             pin_type);
15954         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15955                             AMP_OUT_UNMUTE);
15956         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
15957                 return;
15958         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15959         if (num < 0)
15960                 return;
15961         for (i = 0; i < num; i++) {
15962                 unsigned int mute;
15963                 if (srcs[i] == dac || srcs[i] == 0x15)
15964                         mute = AMP_IN_UNMUTE(i);
15965                 else
15966                         mute = AMP_IN_MUTE(i);
15967                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15968                                     mute);
15969         }
15970 }
15971
15972 static void alc861_auto_init_multi_out(struct hda_codec *codec)
15973 {
15974         struct alc_spec *spec = codec->spec;
15975         int i;
15976
15977         for (i = 0; i < spec->autocfg.line_outs; i++) {
15978                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
15979                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
15980                 if (nid)
15981                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
15982                                                           spec->multiout.dac_nids[i]);
15983         }
15984 }
15985
15986 static void alc861_auto_init_hp_out(struct hda_codec *codec)
15987 {
15988         struct alc_spec *spec = codec->spec;
15989
15990         if (spec->autocfg.hp_outs)
15991                 alc861_auto_set_output_and_unmute(codec,
15992                                                   spec->autocfg.hp_pins[0],
15993                                                   PIN_HP,
15994                                                   spec->multiout.hp_nid);
15995         if (spec->autocfg.speaker_outs)
15996                 alc861_auto_set_output_and_unmute(codec,
15997                                                   spec->autocfg.speaker_pins[0],
15998                                                   PIN_OUT,
15999                                                   spec->multiout.dac_nids[0]);
16000 }
16001
16002 static void alc861_auto_init_analog_input(struct hda_codec *codec)
16003 {
16004         struct alc_spec *spec = codec->spec;
16005         struct auto_pin_cfg *cfg = &spec->autocfg;
16006         int i;
16007
16008         for (i = 0; i < cfg->num_inputs; i++) {
16009                 hda_nid_t nid = cfg->inputs[i].pin;
16010                 if (nid >= 0x0c && nid <= 0x11)
16011                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
16012         }
16013 }
16014
16015 /* parse the BIOS configuration and set up the alc_spec */
16016 /* return 1 if successful, 0 if the proper config is not found,
16017  * or a negative error code
16018  */
16019 static int alc861_parse_auto_config(struct hda_codec *codec)
16020 {
16021         struct alc_spec *spec = codec->spec;
16022         int err;
16023         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
16024
16025         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16026                                            alc861_ignore);
16027         if (err < 0)
16028                 return err;
16029         if (!spec->autocfg.line_outs)
16030                 return 0; /* can't find valid BIOS pin config */
16031
16032         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
16033         if (err < 0)
16034                 return err;
16035         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
16036         if (err < 0)
16037                 return err;
16038         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
16039         if (err < 0)
16040                 return err;
16041         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
16042         if (err < 0)
16043                 return err;
16044
16045         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16046
16047         alc_auto_parse_digital(codec);
16048
16049         if (spec->kctls.list)
16050                 add_mixer(spec, spec->kctls.list);
16051
16052         add_verb(spec, alc861_auto_init_verbs);
16053
16054         spec->num_mux_defs = 1;
16055         spec->input_mux = &spec->private_imux[0];
16056
16057         spec->adc_nids = alc861_adc_nids;
16058         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
16059         set_capture_mixer(codec);
16060
16061         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
16062
16063         return 1;
16064 }
16065
16066 /* additional initialization for auto-configuration model */
16067 static void alc861_auto_init(struct hda_codec *codec)
16068 {
16069         struct alc_spec *spec = codec->spec;
16070         alc861_auto_init_multi_out(codec);
16071         alc861_auto_init_hp_out(codec);
16072         alc861_auto_init_analog_input(codec);
16073         alc_auto_init_digital(codec);
16074         if (spec->unsol_event)
16075                 alc_inithook(codec);
16076 }
16077
16078 #ifdef CONFIG_SND_HDA_POWER_SAVE
16079 static struct hda_amp_list alc861_loopbacks[] = {
16080         { 0x15, HDA_INPUT, 0 },
16081         { 0x15, HDA_INPUT, 1 },
16082         { 0x15, HDA_INPUT, 2 },
16083         { 0x15, HDA_INPUT, 3 },
16084         { } /* end */
16085 };
16086 #endif
16087
16088
16089 /*
16090  * configuration and preset
16091  */
16092 static const char *alc861_models[ALC861_MODEL_LAST] = {
16093         [ALC861_3ST]            = "3stack",
16094         [ALC660_3ST]            = "3stack-660",
16095         [ALC861_3ST_DIG]        = "3stack-dig",
16096         [ALC861_6ST_DIG]        = "6stack-dig",
16097         [ALC861_UNIWILL_M31]    = "uniwill-m31",
16098         [ALC861_TOSHIBA]        = "toshiba",
16099         [ALC861_ASUS]           = "asus",
16100         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
16101         [ALC861_AUTO]           = "auto",
16102 };
16103
16104 static struct snd_pci_quirk alc861_cfg_tbl[] = {
16105         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
16106         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16107         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16108         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
16109         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
16110         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
16111         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
16112         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
16113          *        Any other models that need this preset?
16114          */
16115         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
16116         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
16117         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
16118         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
16119         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
16120         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
16121         /* FIXME: the below seems conflict */
16122         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
16123         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
16124         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
16125         {}
16126 };
16127
16128 static struct alc_config_preset alc861_presets[] = {
16129         [ALC861_3ST] = {
16130                 .mixers = { alc861_3ST_mixer },
16131                 .init_verbs = { alc861_threestack_init_verbs },
16132                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16133                 .dac_nids = alc861_dac_nids,
16134                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16135                 .channel_mode = alc861_threestack_modes,
16136                 .need_dac_fix = 1,
16137                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16138                 .adc_nids = alc861_adc_nids,
16139                 .input_mux = &alc861_capture_source,
16140         },
16141         [ALC861_3ST_DIG] = {
16142                 .mixers = { alc861_base_mixer },
16143                 .init_verbs = { alc861_threestack_init_verbs },
16144                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16145                 .dac_nids = alc861_dac_nids,
16146                 .dig_out_nid = ALC861_DIGOUT_NID,
16147                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16148                 .channel_mode = alc861_threestack_modes,
16149                 .need_dac_fix = 1,
16150                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16151                 .adc_nids = alc861_adc_nids,
16152                 .input_mux = &alc861_capture_source,
16153         },
16154         [ALC861_6ST_DIG] = {
16155                 .mixers = { alc861_base_mixer },
16156                 .init_verbs = { alc861_base_init_verbs },
16157                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16158                 .dac_nids = alc861_dac_nids,
16159                 .dig_out_nid = ALC861_DIGOUT_NID,
16160                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
16161                 .channel_mode = alc861_8ch_modes,
16162                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16163                 .adc_nids = alc861_adc_nids,
16164                 .input_mux = &alc861_capture_source,
16165         },
16166         [ALC660_3ST] = {
16167                 .mixers = { alc861_3ST_mixer },
16168                 .init_verbs = { alc861_threestack_init_verbs },
16169                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
16170                 .dac_nids = alc660_dac_nids,
16171                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16172                 .channel_mode = alc861_threestack_modes,
16173                 .need_dac_fix = 1,
16174                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16175                 .adc_nids = alc861_adc_nids,
16176                 .input_mux = &alc861_capture_source,
16177         },
16178         [ALC861_UNIWILL_M31] = {
16179                 .mixers = { alc861_uniwill_m31_mixer },
16180                 .init_verbs = { alc861_uniwill_m31_init_verbs },
16181                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16182                 .dac_nids = alc861_dac_nids,
16183                 .dig_out_nid = ALC861_DIGOUT_NID,
16184                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
16185                 .channel_mode = alc861_uniwill_m31_modes,
16186                 .need_dac_fix = 1,
16187                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16188                 .adc_nids = alc861_adc_nids,
16189                 .input_mux = &alc861_capture_source,
16190         },
16191         [ALC861_TOSHIBA] = {
16192                 .mixers = { alc861_toshiba_mixer },
16193                 .init_verbs = { alc861_base_init_verbs,
16194                                 alc861_toshiba_init_verbs },
16195                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16196                 .dac_nids = alc861_dac_nids,
16197                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16198                 .channel_mode = alc883_3ST_2ch_modes,
16199                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16200                 .adc_nids = alc861_adc_nids,
16201                 .input_mux = &alc861_capture_source,
16202                 .unsol_event = alc861_toshiba_unsol_event,
16203                 .init_hook = alc861_toshiba_automute,
16204         },
16205         [ALC861_ASUS] = {
16206                 .mixers = { alc861_asus_mixer },
16207                 .init_verbs = { alc861_asus_init_verbs },
16208                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16209                 .dac_nids = alc861_dac_nids,
16210                 .dig_out_nid = ALC861_DIGOUT_NID,
16211                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
16212                 .channel_mode = alc861_asus_modes,
16213                 .need_dac_fix = 1,
16214                 .hp_nid = 0x06,
16215                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16216                 .adc_nids = alc861_adc_nids,
16217                 .input_mux = &alc861_capture_source,
16218         },
16219         [ALC861_ASUS_LAPTOP] = {
16220                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
16221                 .init_verbs = { alc861_asus_init_verbs,
16222                                 alc861_asus_laptop_init_verbs },
16223                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16224                 .dac_nids = alc861_dac_nids,
16225                 .dig_out_nid = ALC861_DIGOUT_NID,
16226                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16227                 .channel_mode = alc883_3ST_2ch_modes,
16228                 .need_dac_fix = 1,
16229                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16230                 .adc_nids = alc861_adc_nids,
16231                 .input_mux = &alc861_capture_source,
16232         },
16233 };
16234
16235 /* Pin config fixes */
16236 enum {
16237         PINFIX_FSC_AMILO_PI1505,
16238 };
16239
16240 static const struct alc_fixup alc861_fixups[] = {
16241         [PINFIX_FSC_AMILO_PI1505] = {
16242                 .pins = (const struct alc_pincfg[]) {
16243                         { 0x0b, 0x0221101f }, /* HP */
16244                         { 0x0f, 0x90170310 }, /* speaker */
16245                         { }
16246                 }
16247         },
16248 };
16249
16250 static struct snd_pci_quirk alc861_fixup_tbl[] = {
16251         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
16252         {}
16253 };
16254
16255 static int patch_alc861(struct hda_codec *codec)
16256 {
16257         struct alc_spec *spec;
16258         int board_config;
16259         int err;
16260
16261         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16262         if (spec == NULL)
16263                 return -ENOMEM;
16264
16265         codec->spec = spec;
16266
16267         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
16268                                                   alc861_models,
16269                                                   alc861_cfg_tbl);
16270
16271         if (board_config < 0) {
16272                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16273                        codec->chip_name);
16274                 board_config = ALC861_AUTO;
16275         }
16276
16277         if (board_config == ALC861_AUTO)
16278                 alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 1);
16279
16280         if (board_config == ALC861_AUTO) {
16281                 /* automatic parse from the BIOS config */
16282                 err = alc861_parse_auto_config(codec);
16283                 if (err < 0) {
16284                         alc_free(codec);
16285                         return err;
16286                 } else if (!err) {
16287                         printk(KERN_INFO
16288                                "hda_codec: Cannot set up configuration "
16289                                "from BIOS.  Using base mode...\n");
16290                    board_config = ALC861_3ST_DIG;
16291                 }
16292         }
16293
16294         err = snd_hda_attach_beep_device(codec, 0x23);
16295         if (err < 0) {
16296                 alc_free(codec);
16297                 return err;
16298         }
16299
16300         if (board_config != ALC861_AUTO)
16301                 setup_preset(codec, &alc861_presets[board_config]);
16302
16303         spec->stream_analog_playback = &alc861_pcm_analog_playback;
16304         spec->stream_analog_capture = &alc861_pcm_analog_capture;
16305
16306         spec->stream_digital_playback = &alc861_pcm_digital_playback;
16307         spec->stream_digital_capture = &alc861_pcm_digital_capture;
16308
16309         if (!spec->cap_mixer)
16310                 set_capture_mixer(codec);
16311         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
16312
16313         spec->vmaster_nid = 0x03;
16314
16315         if (board_config == ALC861_AUTO)
16316                 alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 0);
16317
16318         codec->patch_ops = alc_patch_ops;
16319         if (board_config == ALC861_AUTO) {
16320                 spec->init_hook = alc861_auto_init;
16321 #ifdef CONFIG_SND_HDA_POWER_SAVE
16322                 spec->power_hook = alc_power_eapd;
16323 #endif
16324         }
16325 #ifdef CONFIG_SND_HDA_POWER_SAVE
16326         if (!spec->loopback.amplist)
16327                 spec->loopback.amplist = alc861_loopbacks;
16328 #endif
16329
16330         return 0;
16331 }
16332
16333 /*
16334  * ALC861-VD support
16335  *
16336  * Based on ALC882
16337  *
16338  * In addition, an independent DAC
16339  */
16340 #define ALC861VD_DIGOUT_NID     0x06
16341
16342 static hda_nid_t alc861vd_dac_nids[4] = {
16343         /* front, surr, clfe, side surr */
16344         0x02, 0x03, 0x04, 0x05
16345 };
16346
16347 /* dac_nids for ALC660vd are in a different order - according to
16348  * Realtek's driver.
16349  * This should probably result in a different mixer for 6stack models
16350  * of ALC660vd codecs, but for now there is only 3stack mixer
16351  * - and it is the same as in 861vd.
16352  * adc_nids in ALC660vd are (is) the same as in 861vd
16353  */
16354 static hda_nid_t alc660vd_dac_nids[3] = {
16355         /* front, rear, clfe, rear_surr */
16356         0x02, 0x04, 0x03
16357 };
16358
16359 static hda_nid_t alc861vd_adc_nids[1] = {
16360         /* ADC0 */
16361         0x09,
16362 };
16363
16364 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
16365
16366 /* input MUX */
16367 /* FIXME: should be a matrix-type input source selection */
16368 static struct hda_input_mux alc861vd_capture_source = {
16369         .num_items = 4,
16370         .items = {
16371                 { "Mic", 0x0 },
16372                 { "Front Mic", 0x1 },
16373                 { "Line", 0x2 },
16374                 { "CD", 0x4 },
16375         },
16376 };
16377
16378 static struct hda_input_mux alc861vd_dallas_capture_source = {
16379         .num_items = 2,
16380         .items = {
16381                 { "Ext Mic", 0x0 },
16382                 { "Int Mic", 0x1 },
16383         },
16384 };
16385
16386 static struct hda_input_mux alc861vd_hp_capture_source = {
16387         .num_items = 2,
16388         .items = {
16389                 { "Front Mic", 0x0 },
16390                 { "ATAPI Mic", 0x1 },
16391         },
16392 };
16393
16394 /*
16395  * 2ch mode
16396  */
16397 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
16398         { 2, NULL }
16399 };
16400
16401 /*
16402  * 6ch mode
16403  */
16404 static struct hda_verb alc861vd_6stack_ch6_init[] = {
16405         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16406         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16407         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16408         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16409         { } /* end */
16410 };
16411
16412 /*
16413  * 8ch mode
16414  */
16415 static struct hda_verb alc861vd_6stack_ch8_init[] = {
16416         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16417         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16418         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16419         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16420         { } /* end */
16421 };
16422
16423 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
16424         { 6, alc861vd_6stack_ch6_init },
16425         { 8, alc861vd_6stack_ch8_init },
16426 };
16427
16428 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
16429         {
16430                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16431                 .name = "Channel Mode",
16432                 .info = alc_ch_mode_info,
16433                 .get = alc_ch_mode_get,
16434                 .put = alc_ch_mode_put,
16435         },
16436         { } /* end */
16437 };
16438
16439 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16440  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16441  */
16442 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
16443         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16444         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16445
16446         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16447         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
16448
16449         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
16450                                 HDA_OUTPUT),
16451         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
16452                                 HDA_OUTPUT),
16453         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
16454         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
16455
16456         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
16457         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
16458
16459         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16460
16461         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16462         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16463         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16464
16465         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16466         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16467         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16468
16469         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16470         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16471
16472         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16473         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16474
16475         { } /* end */
16476 };
16477
16478 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
16479         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16480         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16481
16482         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16483
16484         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16485         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16486         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16487
16488         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16489         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16490         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16491
16492         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16493         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16494
16495         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16496         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16497
16498         { } /* end */
16499 };
16500
16501 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
16502         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16503         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
16504         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16505
16506         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16507
16508         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16509         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16510         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16511
16512         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16513         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16514         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16515
16516         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16517         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16518
16519         { } /* end */
16520 };
16521
16522 /* Pin assignment: Speaker=0x14, HP = 0x15,
16523  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
16524  */
16525 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
16526         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16527         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
16528         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16529         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16530         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
16531         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16532         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16533         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
16534         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16535         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16536         { } /* end */
16537 };
16538
16539 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
16540  *                 Front Mic=0x18, ATAPI Mic = 0x19,
16541  */
16542 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
16543         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16544         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16545         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16546         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16547         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16548         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16549         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16550         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16551
16552         { } /* end */
16553 };
16554
16555 /*
16556  * generic initialization of ADC, input mixers and output mixers
16557  */
16558 static struct hda_verb alc861vd_volume_init_verbs[] = {
16559         /*
16560          * Unmute ADC0 and set the default input to mic-in
16561          */
16562         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16563         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16564
16565         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
16566          * the analog-loopback mixer widget
16567          */
16568         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16569         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16570         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16571         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16572         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16573         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16574
16575         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
16576         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16577         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16578         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
16579         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
16580
16581         /*
16582          * Set up output mixers (0x02 - 0x05)
16583          */
16584         /* set vol=0 to output mixers */
16585         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16586         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16587         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16588         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16589
16590         /* set up input amps for analog loopback */
16591         /* Amp Indices: DAC = 0, mixer = 1 */
16592         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16593         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16594         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16595         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16596         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16597         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16598         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16599         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16600
16601         { }
16602 };
16603
16604 /*
16605  * 3-stack pin configuration:
16606  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
16607  */
16608 static struct hda_verb alc861vd_3stack_init_verbs[] = {
16609         /*
16610          * Set pin mode and muting
16611          */
16612         /* set front pin widgets 0x14 for output */
16613         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16614         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16615         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16616
16617         /* Mic (rear) pin: input vref at 80% */
16618         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16619         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16620         /* Front Mic pin: input vref at 80% */
16621         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16622         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16623         /* Line In pin: input */
16624         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16625         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16626         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16627         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16628         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16629         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16630         /* CD pin widget for input */
16631         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16632
16633         { }
16634 };
16635
16636 /*
16637  * 6-stack pin configuration:
16638  */
16639 static struct hda_verb alc861vd_6stack_init_verbs[] = {
16640         /*
16641          * Set pin mode and muting
16642          */
16643         /* set front pin widgets 0x14 for output */
16644         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16645         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16646         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16647
16648         /* Rear Pin: output 1 (0x0d) */
16649         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16650         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16651         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16652         /* CLFE Pin: output 2 (0x0e) */
16653         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16654         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16655         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
16656         /* Side Pin: output 3 (0x0f) */
16657         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16658         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16659         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
16660
16661         /* Mic (rear) pin: input vref at 80% */
16662         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16663         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16664         /* Front Mic pin: input vref at 80% */
16665         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16666         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16667         /* Line In pin: input */
16668         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16669         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16670         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16671         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16672         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16673         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16674         /* CD pin widget for input */
16675         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16676
16677         { }
16678 };
16679
16680 static struct hda_verb alc861vd_eapd_verbs[] = {
16681         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16682         { }
16683 };
16684
16685 static struct hda_verb alc660vd_eapd_verbs[] = {
16686         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16687         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16688         { }
16689 };
16690
16691 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
16692         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16693         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16694         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
16695         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16696         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16697         {}
16698 };
16699
16700 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
16701 {
16702         unsigned int present;
16703         unsigned char bits;
16704
16705         present = snd_hda_jack_detect(codec, 0x18);
16706         bits = present ? HDA_AMP_MUTE : 0;
16707
16708         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
16709                                  HDA_AMP_MUTE, bits);
16710 }
16711
16712 static void alc861vd_lenovo_setup(struct hda_codec *codec)
16713 {
16714         struct alc_spec *spec = codec->spec;
16715         spec->autocfg.hp_pins[0] = 0x1b;
16716         spec->autocfg.speaker_pins[0] = 0x14;
16717 }
16718
16719 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
16720 {
16721         alc_automute_amp(codec);
16722         alc861vd_lenovo_mic_automute(codec);
16723 }
16724
16725 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
16726                                         unsigned int res)
16727 {
16728         switch (res >> 26) {
16729         case ALC880_MIC_EVENT:
16730                 alc861vd_lenovo_mic_automute(codec);
16731                 break;
16732         default:
16733                 alc_automute_amp_unsol_event(codec, res);
16734                 break;
16735         }
16736 }
16737
16738 static struct hda_verb alc861vd_dallas_verbs[] = {
16739         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16740         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16741         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16742         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16743
16744         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16745         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16746         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16747         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16748         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16749         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16750         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16751         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16752
16753         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16754         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16755         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16756         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16757         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16758         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16759         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16760         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16761
16762         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16763         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16764         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16765         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16766         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16767         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16768         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16769         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16770
16771         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16772         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16773         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16774         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16775
16776         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16777         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16778         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16779
16780         { } /* end */
16781 };
16782
16783 /* toggle speaker-output according to the hp-jack state */
16784 static void alc861vd_dallas_setup(struct hda_codec *codec)
16785 {
16786         struct alc_spec *spec = codec->spec;
16787
16788         spec->autocfg.hp_pins[0] = 0x15;
16789         spec->autocfg.speaker_pins[0] = 0x14;
16790 }
16791
16792 #ifdef CONFIG_SND_HDA_POWER_SAVE
16793 #define alc861vd_loopbacks      alc880_loopbacks
16794 #endif
16795
16796 /* pcm configuration: identical with ALC880 */
16797 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
16798 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
16799 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
16800 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
16801
16802 /*
16803  * configuration and preset
16804  */
16805 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
16806         [ALC660VD_3ST]          = "3stack-660",
16807         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
16808         [ALC660VD_ASUS_V1S]     = "asus-v1s",
16809         [ALC861VD_3ST]          = "3stack",
16810         [ALC861VD_3ST_DIG]      = "3stack-digout",
16811         [ALC861VD_6ST_DIG]      = "6stack-digout",
16812         [ALC861VD_LENOVO]       = "lenovo",
16813         [ALC861VD_DALLAS]       = "dallas",
16814         [ALC861VD_HP]           = "hp",
16815         [ALC861VD_AUTO]         = "auto",
16816 };
16817
16818 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
16819         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
16820         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
16821         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
16822         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
16823         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
16824         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
16825         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
16826         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
16827         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
16828         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
16829         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
16830         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
16831         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
16832         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
16833         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
16834         {}
16835 };
16836
16837 static struct alc_config_preset alc861vd_presets[] = {
16838         [ALC660VD_3ST] = {
16839                 .mixers = { alc861vd_3st_mixer },
16840                 .init_verbs = { alc861vd_volume_init_verbs,
16841                                  alc861vd_3stack_init_verbs },
16842                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16843                 .dac_nids = alc660vd_dac_nids,
16844                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16845                 .channel_mode = alc861vd_3stack_2ch_modes,
16846                 .input_mux = &alc861vd_capture_source,
16847         },
16848         [ALC660VD_3ST_DIG] = {
16849                 .mixers = { alc861vd_3st_mixer },
16850                 .init_verbs = { alc861vd_volume_init_verbs,
16851                                  alc861vd_3stack_init_verbs },
16852                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16853                 .dac_nids = alc660vd_dac_nids,
16854                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16855                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16856                 .channel_mode = alc861vd_3stack_2ch_modes,
16857                 .input_mux = &alc861vd_capture_source,
16858         },
16859         [ALC861VD_3ST] = {
16860                 .mixers = { alc861vd_3st_mixer },
16861                 .init_verbs = { alc861vd_volume_init_verbs,
16862                                  alc861vd_3stack_init_verbs },
16863                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16864                 .dac_nids = alc861vd_dac_nids,
16865                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16866                 .channel_mode = alc861vd_3stack_2ch_modes,
16867                 .input_mux = &alc861vd_capture_source,
16868         },
16869         [ALC861VD_3ST_DIG] = {
16870                 .mixers = { alc861vd_3st_mixer },
16871                 .init_verbs = { alc861vd_volume_init_verbs,
16872                                  alc861vd_3stack_init_verbs },
16873                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16874                 .dac_nids = alc861vd_dac_nids,
16875                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16876                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16877                 .channel_mode = alc861vd_3stack_2ch_modes,
16878                 .input_mux = &alc861vd_capture_source,
16879         },
16880         [ALC861VD_6ST_DIG] = {
16881                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
16882                 .init_verbs = { alc861vd_volume_init_verbs,
16883                                 alc861vd_6stack_init_verbs },
16884                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16885                 .dac_nids = alc861vd_dac_nids,
16886                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16887                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
16888                 .channel_mode = alc861vd_6stack_modes,
16889                 .input_mux = &alc861vd_capture_source,
16890         },
16891         [ALC861VD_LENOVO] = {
16892                 .mixers = { alc861vd_lenovo_mixer },
16893                 .init_verbs = { alc861vd_volume_init_verbs,
16894                                 alc861vd_3stack_init_verbs,
16895                                 alc861vd_eapd_verbs,
16896                                 alc861vd_lenovo_unsol_verbs },
16897                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16898                 .dac_nids = alc660vd_dac_nids,
16899                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16900                 .channel_mode = alc861vd_3stack_2ch_modes,
16901                 .input_mux = &alc861vd_capture_source,
16902                 .unsol_event = alc861vd_lenovo_unsol_event,
16903                 .setup = alc861vd_lenovo_setup,
16904                 .init_hook = alc861vd_lenovo_init_hook,
16905         },
16906         [ALC861VD_DALLAS] = {
16907                 .mixers = { alc861vd_dallas_mixer },
16908                 .init_verbs = { alc861vd_dallas_verbs },
16909                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16910                 .dac_nids = alc861vd_dac_nids,
16911                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16912                 .channel_mode = alc861vd_3stack_2ch_modes,
16913                 .input_mux = &alc861vd_dallas_capture_source,
16914                 .unsol_event = alc_automute_amp_unsol_event,
16915                 .setup = alc861vd_dallas_setup,
16916                 .init_hook = alc_automute_amp,
16917         },
16918         [ALC861VD_HP] = {
16919                 .mixers = { alc861vd_hp_mixer },
16920                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
16921                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16922                 .dac_nids = alc861vd_dac_nids,
16923                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16924                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16925                 .channel_mode = alc861vd_3stack_2ch_modes,
16926                 .input_mux = &alc861vd_hp_capture_source,
16927                 .unsol_event = alc_automute_amp_unsol_event,
16928                 .setup = alc861vd_dallas_setup,
16929                 .init_hook = alc_automute_amp,
16930         },
16931         [ALC660VD_ASUS_V1S] = {
16932                 .mixers = { alc861vd_lenovo_mixer },
16933                 .init_verbs = { alc861vd_volume_init_verbs,
16934                                 alc861vd_3stack_init_verbs,
16935                                 alc861vd_eapd_verbs,
16936                                 alc861vd_lenovo_unsol_verbs },
16937                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16938                 .dac_nids = alc660vd_dac_nids,
16939                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16940                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16941                 .channel_mode = alc861vd_3stack_2ch_modes,
16942                 .input_mux = &alc861vd_capture_source,
16943                 .unsol_event = alc861vd_lenovo_unsol_event,
16944                 .setup = alc861vd_lenovo_setup,
16945                 .init_hook = alc861vd_lenovo_init_hook,
16946         },
16947 };
16948
16949 /*
16950  * BIOS auto configuration
16951  */
16952 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
16953                                                 const struct auto_pin_cfg *cfg)
16954 {
16955         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x22, 0);
16956 }
16957
16958
16959 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
16960                                 hda_nid_t nid, int pin_type, int dac_idx)
16961 {
16962         alc_set_pin_output(codec, nid, pin_type);
16963 }
16964
16965 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
16966 {
16967         struct alc_spec *spec = codec->spec;
16968         int i;
16969
16970         for (i = 0; i <= HDA_SIDE; i++) {
16971                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16972                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16973                 if (nid)
16974                         alc861vd_auto_set_output_and_unmute(codec, nid,
16975                                                             pin_type, i);
16976         }
16977 }
16978
16979
16980 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
16981 {
16982         struct alc_spec *spec = codec->spec;
16983         hda_nid_t pin;
16984
16985         pin = spec->autocfg.hp_pins[0];
16986         if (pin) /* connect to front and use dac 0 */
16987                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16988         pin = spec->autocfg.speaker_pins[0];
16989         if (pin)
16990                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16991 }
16992
16993 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
16994
16995 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
16996 {
16997         struct alc_spec *spec = codec->spec;
16998         struct auto_pin_cfg *cfg = &spec->autocfg;
16999         int i;
17000
17001         for (i = 0; i < cfg->num_inputs; i++) {
17002                 hda_nid_t nid = cfg->inputs[i].pin;
17003                 if (alc_is_input_pin(codec, nid)) {
17004                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
17005                         if (nid != ALC861VD_PIN_CD_NID &&
17006                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17007                                 snd_hda_codec_write(codec, nid, 0,
17008                                                 AC_VERB_SET_AMP_GAIN_MUTE,
17009                                                 AMP_OUT_MUTE);
17010                 }
17011         }
17012 }
17013
17014 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
17015
17016 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
17017 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
17018
17019 /* add playback controls from the parsed DAC table */
17020 /* Based on ALC880 version. But ALC861VD has separate,
17021  * different NIDs for mute/unmute switch and volume control */
17022 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
17023                                              const struct auto_pin_cfg *cfg)
17024 {
17025         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
17026         hda_nid_t nid_v, nid_s;
17027         int i, err;
17028
17029         for (i = 0; i < cfg->line_outs; i++) {
17030                 if (!spec->multiout.dac_nids[i])
17031                         continue;
17032                 nid_v = alc861vd_idx_to_mixer_vol(
17033                                 alc880_dac_to_idx(
17034                                         spec->multiout.dac_nids[i]));
17035                 nid_s = alc861vd_idx_to_mixer_switch(
17036                                 alc880_dac_to_idx(
17037                                         spec->multiout.dac_nids[i]));
17038
17039                 if (i == 2) {
17040                         /* Center/LFE */
17041                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17042                                               "Center",
17043                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
17044                                                               HDA_OUTPUT));
17045                         if (err < 0)
17046                                 return err;
17047                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17048                                               "LFE",
17049                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
17050                                                               HDA_OUTPUT));
17051                         if (err < 0)
17052                                 return err;
17053                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17054                                              "Center",
17055                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
17056                                                               HDA_INPUT));
17057                         if (err < 0)
17058                                 return err;
17059                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17060                                              "LFE",
17061                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
17062                                                               HDA_INPUT));
17063                         if (err < 0)
17064                                 return err;
17065                 } else {
17066                         const char *pfx;
17067                         if (cfg->line_outs == 1 &&
17068                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
17069                                 if (!cfg->hp_pins)
17070                                         pfx = "Speaker";
17071                                 else
17072                                         pfx = "PCM";
17073                         } else
17074                                 pfx = chname[i];
17075                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17076                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
17077                                                               HDA_OUTPUT));
17078                         if (err < 0)
17079                                 return err;
17080                         if (cfg->line_outs == 1 &&
17081                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
17082                                 pfx = "Speaker";
17083                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17084                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
17085                                                               HDA_INPUT));
17086                         if (err < 0)
17087                                 return err;
17088                 }
17089         }
17090         return 0;
17091 }
17092
17093 /* add playback controls for speaker and HP outputs */
17094 /* Based on ALC880 version. But ALC861VD has separate,
17095  * different NIDs for mute/unmute switch and volume control */
17096 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
17097                                         hda_nid_t pin, const char *pfx)
17098 {
17099         hda_nid_t nid_v, nid_s;
17100         int err;
17101
17102         if (!pin)
17103                 return 0;
17104
17105         if (alc880_is_fixed_pin(pin)) {
17106                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
17107                 /* specify the DAC as the extra output */
17108                 if (!spec->multiout.hp_nid)
17109                         spec->multiout.hp_nid = nid_v;
17110                 else
17111                         spec->multiout.extra_out_nid[0] = nid_v;
17112                 /* control HP volume/switch on the output mixer amp */
17113                 nid_v = alc861vd_idx_to_mixer_vol(
17114                                 alc880_fixed_pin_idx(pin));
17115                 nid_s = alc861vd_idx_to_mixer_switch(
17116                                 alc880_fixed_pin_idx(pin));
17117
17118                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17119                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
17120                 if (err < 0)
17121                         return err;
17122                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17123                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
17124                 if (err < 0)
17125                         return err;
17126         } else if (alc880_is_multi_pin(pin)) {
17127                 /* set manual connection */
17128                 /* we have only a switch on HP-out PIN */
17129                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17130                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17131                 if (err < 0)
17132                         return err;
17133         }
17134         return 0;
17135 }
17136
17137 /* parse the BIOS configuration and set up the alc_spec
17138  * return 1 if successful, 0 if the proper config is not found,
17139  * or a negative error code
17140  * Based on ALC880 version - had to change it to override
17141  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
17142 static int alc861vd_parse_auto_config(struct hda_codec *codec)
17143 {
17144         struct alc_spec *spec = codec->spec;
17145         int err;
17146         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
17147
17148         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17149                                            alc861vd_ignore);
17150         if (err < 0)
17151                 return err;
17152         if (!spec->autocfg.line_outs)
17153                 return 0; /* can't find valid BIOS pin config */
17154
17155         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17156         if (err < 0)
17157                 return err;
17158         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
17159         if (err < 0)
17160                 return err;
17161         err = alc861vd_auto_create_extra_out(spec,
17162                                              spec->autocfg.speaker_pins[0],
17163                                              "Speaker");
17164         if (err < 0)
17165                 return err;
17166         err = alc861vd_auto_create_extra_out(spec,
17167                                              spec->autocfg.hp_pins[0],
17168                                              "Headphone");
17169         if (err < 0)
17170                 return err;
17171         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
17172         if (err < 0)
17173                 return err;
17174
17175         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17176
17177         alc_auto_parse_digital(codec);
17178
17179         if (spec->kctls.list)
17180                 add_mixer(spec, spec->kctls.list);
17181
17182         add_verb(spec, alc861vd_volume_init_verbs);
17183
17184         spec->num_mux_defs = 1;
17185         spec->input_mux = &spec->private_imux[0];
17186
17187         err = alc_auto_add_mic_boost(codec);
17188         if (err < 0)
17189                 return err;
17190
17191         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
17192
17193         return 1;
17194 }
17195
17196 /* additional initialization for auto-configuration model */
17197 static void alc861vd_auto_init(struct hda_codec *codec)
17198 {
17199         struct alc_spec *spec = codec->spec;
17200         alc861vd_auto_init_multi_out(codec);
17201         alc861vd_auto_init_hp_out(codec);
17202         alc861vd_auto_init_analog_input(codec);
17203         alc861vd_auto_init_input_src(codec);
17204         alc_auto_init_digital(codec);
17205         if (spec->unsol_event)
17206                 alc_inithook(codec);
17207 }
17208
17209 enum {
17210         ALC660VD_FIX_ASUS_GPIO1
17211 };
17212
17213 /* reset GPIO1 */
17214 static const struct alc_fixup alc861vd_fixups[] = {
17215         [ALC660VD_FIX_ASUS_GPIO1] = {
17216                 .verbs = (const struct hda_verb[]) {
17217                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
17218                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
17219                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
17220                         { }
17221                 }
17222         },
17223 };
17224
17225 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
17226         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
17227         {}
17228 };
17229
17230 static int patch_alc861vd(struct hda_codec *codec)
17231 {
17232         struct alc_spec *spec;
17233         int err, board_config;
17234
17235         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17236         if (spec == NULL)
17237                 return -ENOMEM;
17238
17239         codec->spec = spec;
17240
17241         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
17242                                                   alc861vd_models,
17243                                                   alc861vd_cfg_tbl);
17244
17245         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
17246                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17247                        codec->chip_name);
17248                 board_config = ALC861VD_AUTO;
17249         }
17250
17251         if (board_config == ALC861VD_AUTO)
17252                 alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 1);
17253
17254         if (board_config == ALC861VD_AUTO) {
17255                 /* automatic parse from the BIOS config */
17256                 err = alc861vd_parse_auto_config(codec);
17257                 if (err < 0) {
17258                         alc_free(codec);
17259                         return err;
17260                 } else if (!err) {
17261                         printk(KERN_INFO
17262                                "hda_codec: Cannot set up configuration "
17263                                "from BIOS.  Using base mode...\n");
17264                         board_config = ALC861VD_3ST;
17265                 }
17266         }
17267
17268         err = snd_hda_attach_beep_device(codec, 0x23);
17269         if (err < 0) {
17270                 alc_free(codec);
17271                 return err;
17272         }
17273
17274         if (board_config != ALC861VD_AUTO)
17275                 setup_preset(codec, &alc861vd_presets[board_config]);
17276
17277         if (codec->vendor_id == 0x10ec0660) {
17278                 /* always turn on EAPD */
17279                 add_verb(spec, alc660vd_eapd_verbs);
17280         }
17281
17282         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
17283         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
17284
17285         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
17286         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
17287
17288         if (!spec->adc_nids) {
17289                 spec->adc_nids = alc861vd_adc_nids;
17290                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
17291         }
17292         if (!spec->capsrc_nids)
17293                 spec->capsrc_nids = alc861vd_capsrc_nids;
17294
17295         set_capture_mixer(codec);
17296         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17297
17298         spec->vmaster_nid = 0x02;
17299
17300         if (board_config == ALC861VD_AUTO)
17301                 alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 0);
17302
17303         codec->patch_ops = alc_patch_ops;
17304
17305         if (board_config == ALC861VD_AUTO)
17306                 spec->init_hook = alc861vd_auto_init;
17307 #ifdef CONFIG_SND_HDA_POWER_SAVE
17308         if (!spec->loopback.amplist)
17309                 spec->loopback.amplist = alc861vd_loopbacks;
17310 #endif
17311
17312         return 0;
17313 }
17314
17315 /*
17316  * ALC662 support
17317  *
17318  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
17319  * configuration.  Each pin widget can choose any input DACs and a mixer.
17320  * Each ADC is connected from a mixer of all inputs.  This makes possible
17321  * 6-channel independent captures.
17322  *
17323  * In addition, an independent DAC for the multi-playback (not used in this
17324  * driver yet).
17325  */
17326 #define ALC662_DIGOUT_NID       0x06
17327 #define ALC662_DIGIN_NID        0x0a
17328
17329 static hda_nid_t alc662_dac_nids[4] = {
17330         /* front, rear, clfe, rear_surr */
17331         0x02, 0x03, 0x04
17332 };
17333
17334 static hda_nid_t alc272_dac_nids[2] = {
17335         0x02, 0x03
17336 };
17337
17338 static hda_nid_t alc662_adc_nids[2] = {
17339         /* ADC1-2 */
17340         0x09, 0x08
17341 };
17342
17343 static hda_nid_t alc272_adc_nids[1] = {
17344         /* ADC1-2 */
17345         0x08,
17346 };
17347
17348 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
17349 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
17350
17351
17352 /* input MUX */
17353 /* FIXME: should be a matrix-type input source selection */
17354 static struct hda_input_mux alc662_capture_source = {
17355         .num_items = 4,
17356         .items = {
17357                 { "Mic", 0x0 },
17358                 { "Front Mic", 0x1 },
17359                 { "Line", 0x2 },
17360                 { "CD", 0x4 },
17361         },
17362 };
17363
17364 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
17365         .num_items = 2,
17366         .items = {
17367                 { "Mic", 0x1 },
17368                 { "Line", 0x2 },
17369         },
17370 };
17371
17372 static struct hda_input_mux alc663_capture_source = {
17373         .num_items = 3,
17374         .items = {
17375                 { "Mic", 0x0 },
17376                 { "Front Mic", 0x1 },
17377                 { "Line", 0x2 },
17378         },
17379 };
17380
17381 #if 0 /* set to 1 for testing other input sources below */
17382 static struct hda_input_mux alc272_nc10_capture_source = {
17383         .num_items = 16,
17384         .items = {
17385                 { "Autoselect Mic", 0x0 },
17386                 { "Internal Mic", 0x1 },
17387                 { "In-0x02", 0x2 },
17388                 { "In-0x03", 0x3 },
17389                 { "In-0x04", 0x4 },
17390                 { "In-0x05", 0x5 },
17391                 { "In-0x06", 0x6 },
17392                 { "In-0x07", 0x7 },
17393                 { "In-0x08", 0x8 },
17394                 { "In-0x09", 0x9 },
17395                 { "In-0x0a", 0x0a },
17396                 { "In-0x0b", 0x0b },
17397                 { "In-0x0c", 0x0c },
17398                 { "In-0x0d", 0x0d },
17399                 { "In-0x0e", 0x0e },
17400                 { "In-0x0f", 0x0f },
17401         },
17402 };
17403 #endif
17404
17405 /*
17406  * 2ch mode
17407  */
17408 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
17409         { 2, NULL }
17410 };
17411
17412 /*
17413  * 2ch mode
17414  */
17415 static struct hda_verb alc662_3ST_ch2_init[] = {
17416         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
17417         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17418         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
17419         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17420         { } /* end */
17421 };
17422
17423 /*
17424  * 6ch mode
17425  */
17426 static struct hda_verb alc662_3ST_ch6_init[] = {
17427         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17428         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17429         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
17430         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17431         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17432         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
17433         { } /* end */
17434 };
17435
17436 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
17437         { 2, alc662_3ST_ch2_init },
17438         { 6, alc662_3ST_ch6_init },
17439 };
17440
17441 /*
17442  * 2ch mode
17443  */
17444 static struct hda_verb alc662_sixstack_ch6_init[] = {
17445         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17446         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17447         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17448         { } /* end */
17449 };
17450
17451 /*
17452  * 6ch mode
17453  */
17454 static struct hda_verb alc662_sixstack_ch8_init[] = {
17455         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17456         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17457         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17458         { } /* end */
17459 };
17460
17461 static struct hda_channel_mode alc662_5stack_modes[2] = {
17462         { 2, alc662_sixstack_ch6_init },
17463         { 6, alc662_sixstack_ch8_init },
17464 };
17465
17466 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
17467  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
17468  */
17469
17470 static struct snd_kcontrol_new alc662_base_mixer[] = {
17471         /* output mixer control */
17472         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
17473         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17474         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
17475         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17476         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17477         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17478         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17479         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17480         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17481
17482         /*Input mixer control */
17483         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
17484         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
17485         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
17486         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
17487         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
17488         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
17489         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
17490         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
17491         { } /* end */
17492 };
17493
17494 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
17495         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17496         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17497         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17498         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17499         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17500         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17501         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17502         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17503         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17504         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17505         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17506         { } /* end */
17507 };
17508
17509 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
17510         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17511         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17512         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17513         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17514         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17515         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17516         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17517         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17518         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17519         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17520         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17521         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17522         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17523         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17524         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17525         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17526         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17527         { } /* end */
17528 };
17529
17530 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
17531         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17532         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
17533         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17534         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
17535         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17536         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17537         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17538         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17539         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17540         { } /* end */
17541 };
17542
17543 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
17544         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17545         ALC262_HIPPO_MASTER_SWITCH,
17546
17547         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
17548         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17549         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17550
17551         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
17552         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17553         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17554         { } /* end */
17555 };
17556
17557 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
17558         ALC262_HIPPO_MASTER_SWITCH,
17559         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17560         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17561         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17562         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17563         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
17564         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17565         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17566         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17567         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17568         { } /* end */
17569 };
17570
17571 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
17572         .ops = &snd_hda_bind_vol,
17573         .values = {
17574                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17575                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
17576                 0
17577         },
17578 };
17579
17580 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
17581         .ops = &snd_hda_bind_sw,
17582         .values = {
17583                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17584                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17585                 0
17586         },
17587 };
17588
17589 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
17590         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17591         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
17592         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17593         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17594         { } /* end */
17595 };
17596
17597 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
17598         .ops = &snd_hda_bind_sw,
17599         .values = {
17600                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17601                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17602                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17603                 0
17604         },
17605 };
17606
17607 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
17608         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17609         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
17610         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17611         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17612         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17613         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17614
17615         { } /* end */
17616 };
17617
17618 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
17619         .ops = &snd_hda_bind_sw,
17620         .values = {
17621                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17622                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17623                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17624                 0
17625         },
17626 };
17627
17628 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
17629         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17630         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
17631         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17632         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17633         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17634         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17635         { } /* end */
17636 };
17637
17638 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
17639         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17640         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17641         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17642         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17643         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17644         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17645         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17646         { } /* end */
17647 };
17648
17649 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
17650         .ops = &snd_hda_bind_vol,
17651         .values = {
17652                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17653                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
17654                 0
17655         },
17656 };
17657
17658 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
17659         .ops = &snd_hda_bind_sw,
17660         .values = {
17661                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17662                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
17663                 0
17664         },
17665 };
17666
17667 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
17668         HDA_BIND_VOL("Master Playback Volume",
17669                                 &alc663_asus_two_bind_master_vol),
17670         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17671         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17672         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17673         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17674         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17675         { } /* end */
17676 };
17677
17678 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
17679         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17680         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17681         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17682         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17683         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17684         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17685         { } /* end */
17686 };
17687
17688 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
17689         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17690         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17691         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17692         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17693         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17694
17695         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17696         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17697         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17698         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17699         { } /* end */
17700 };
17701
17702 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
17703         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17704         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17705         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17706
17707         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17708         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17709         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17710         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17711         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17712         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17713         { } /* end */
17714 };
17715
17716 static struct hda_bind_ctls alc663_asus_mode7_8_all_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(0x15, 3, 0, HDA_OUTPUT),
17721                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17722                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17723                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17724                 0
17725         },
17726 };
17727
17728 static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
17729         .ops = &snd_hda_bind_sw,
17730         .values = {
17731                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17732                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17733                 0
17734         },
17735 };
17736
17737 static struct snd_kcontrol_new alc663_mode7_mixer[] = {
17738         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17739         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17740         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17741         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17742         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17743         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17744         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17745         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17746         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17747         { } /* end */
17748 };
17749
17750 static struct snd_kcontrol_new alc663_mode8_mixer[] = {
17751         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17752         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17753         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17754         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17755         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17756         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17757         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17758         { } /* end */
17759 };
17760
17761
17762 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
17763         {
17764                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
17765                 .name = "Channel Mode",
17766                 .info = alc_ch_mode_info,
17767                 .get = alc_ch_mode_get,
17768                 .put = alc_ch_mode_put,
17769         },
17770         { } /* end */
17771 };
17772
17773 static struct hda_verb alc662_init_verbs[] = {
17774         /* ADC: mute amp left and right */
17775         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17776         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
17777
17778         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17779         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17780         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17781         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17782         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17783         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17784
17785         /* Front Pin: output 0 (0x0c) */
17786         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17787         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17788
17789         /* Rear Pin: output 1 (0x0d) */
17790         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17791         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17792
17793         /* CLFE Pin: output 2 (0x0e) */
17794         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17795         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17796
17797         /* Mic (rear) pin: input vref at 80% */
17798         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17799         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17800         /* Front Mic pin: input vref at 80% */
17801         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17802         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17803         /* Line In pin: input */
17804         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17805         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17806         /* Line-2 In: Headphone output (output 0 - 0x0c) */
17807         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17808         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17809         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
17810         /* CD pin widget for input */
17811         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17812
17813         /* FIXME: use matrix-type input source selection */
17814         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
17815         /* Input mixer */
17816         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17817         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17818
17819         /* always trun on EAPD */
17820         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
17821         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
17822
17823         { }
17824 };
17825
17826 static struct hda_verb alc663_init_verbs[] = {
17827         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17828         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17829         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17830         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17831         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17832         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17833         { }
17834 };
17835
17836 static struct hda_verb alc272_init_verbs[] = {
17837         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17838         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17839         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17840         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17841         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17842         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17843         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17844         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17845         { }
17846 };
17847
17848 static struct hda_verb alc662_sue_init_verbs[] = {
17849         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17850         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17851         {}
17852 };
17853
17854 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
17855         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17856         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17857         {}
17858 };
17859
17860 /* Set Unsolicited Event*/
17861 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
17862         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17863         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17864         {}
17865 };
17866
17867 static struct hda_verb alc663_m51va_init_verbs[] = {
17868         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17869         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17870         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17871         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17872         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17873         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17874         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17875         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17876         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17877         {}
17878 };
17879
17880 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
17881         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17882         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17883         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17884         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17885         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17886         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17887         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17888         {}
17889 };
17890
17891 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
17892         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17893         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17894         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17895         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17896         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17897         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17898         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17899         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17900         {}
17901 };
17902
17903 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
17904         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17905         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17906         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17907         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17908         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17909         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17910         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17911         {}
17912 };
17913
17914 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
17915         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17916         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17917         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17918         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
17919         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17920         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17921         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
17922         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17923         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17924         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17925         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17926         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17927         {}
17928 };
17929
17930 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
17931         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17932         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17933         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17934         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17935         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17936         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17937         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17938         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17939         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17940         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17941         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17942         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17943         {}
17944 };
17945
17946 static struct hda_verb alc663_g71v_init_verbs[] = {
17947         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17948         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
17949         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
17950
17951         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17952         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17953         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17954
17955         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17956         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
17957         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17958         {}
17959 };
17960
17961 static struct hda_verb alc663_g50v_init_verbs[] = {
17962         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17963         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17964         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17965
17966         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17967         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17968         {}
17969 };
17970
17971 static struct hda_verb alc662_ecs_init_verbs[] = {
17972         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
17973         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17974         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17975         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17976         {}
17977 };
17978
17979 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
17980         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17981         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17982         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17983         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17984         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17985         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17986         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17987         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17988         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17989         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17990         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17991         {}
17992 };
17993
17994 static struct hda_verb alc272_dell_init_verbs[] = {
17995         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17996         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17997         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17998         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17999         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18000         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18001         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18002         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18003         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18004         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18005         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18006         {}
18007 };
18008
18009 static struct hda_verb alc663_mode7_init_verbs[] = {
18010         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18011         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18012         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18013         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18014         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18015         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18016         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
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(9)},
18022         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18023         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18024         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18025         {}
18026 };
18027
18028 static struct hda_verb alc663_mode8_init_verbs[] = {
18029         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18030         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18031         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18032         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
18033         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18034         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18035         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18036         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18037         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18038         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18039         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18040         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18041         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18042         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18043         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18044         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18045         {}
18046 };
18047
18048 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
18049         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
18050         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
18051         { } /* end */
18052 };
18053
18054 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
18055         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
18056         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
18057         { } /* end */
18058 };
18059
18060 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
18061 {
18062         unsigned int present;
18063         unsigned char bits;
18064
18065         present = snd_hda_jack_detect(codec, 0x14);
18066         bits = present ? HDA_AMP_MUTE : 0;
18067
18068         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18069                                  HDA_AMP_MUTE, bits);
18070 }
18071
18072 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
18073 {
18074         unsigned int present;
18075         unsigned char bits;
18076
18077         present = snd_hda_jack_detect(codec, 0x1b);
18078         bits = present ? HDA_AMP_MUTE : 0;
18079
18080         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18081                                  HDA_AMP_MUTE, bits);
18082         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18083                                  HDA_AMP_MUTE, bits);
18084 }
18085
18086 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
18087                                            unsigned int res)
18088 {
18089         if ((res >> 26) == ALC880_HP_EVENT)
18090                 alc662_lenovo_101e_all_automute(codec);
18091         if ((res >> 26) == ALC880_FRONT_EVENT)
18092                 alc662_lenovo_101e_ispeaker_automute(codec);
18093 }
18094
18095 /* unsolicited event for HP jack sensing */
18096 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
18097                                      unsigned int res)
18098 {
18099         if ((res >> 26) == ALC880_MIC_EVENT)
18100                 alc_mic_automute(codec);
18101         else
18102                 alc262_hippo_unsol_event(codec, res);
18103 }
18104
18105 static void alc662_eeepc_setup(struct hda_codec *codec)
18106 {
18107         struct alc_spec *spec = codec->spec;
18108
18109         alc262_hippo1_setup(codec);
18110         spec->ext_mic.pin = 0x18;
18111         spec->ext_mic.mux_idx = 0;
18112         spec->int_mic.pin = 0x19;
18113         spec->int_mic.mux_idx = 1;
18114         spec->auto_mic = 1;
18115 }
18116
18117 static void alc662_eeepc_inithook(struct hda_codec *codec)
18118 {
18119         alc262_hippo_automute(codec);
18120         alc_mic_automute(codec);
18121 }
18122
18123 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
18124 {
18125         struct alc_spec *spec = codec->spec;
18126
18127         spec->autocfg.hp_pins[0] = 0x14;
18128         spec->autocfg.speaker_pins[0] = 0x1b;
18129 }
18130
18131 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
18132
18133 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
18134 {
18135         unsigned int present;
18136         unsigned char bits;
18137
18138         present = snd_hda_jack_detect(codec, 0x21);
18139         bits = present ? HDA_AMP_MUTE : 0;
18140         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18141                                  HDA_AMP_MUTE, bits);
18142         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18143                                  HDA_AMP_MUTE, bits);
18144 }
18145
18146 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
18147 {
18148         unsigned int present;
18149         unsigned char bits;
18150
18151         present = snd_hda_jack_detect(codec, 0x21);
18152         bits = present ? HDA_AMP_MUTE : 0;
18153         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18154                                  HDA_AMP_MUTE, bits);
18155         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18156                                  HDA_AMP_MUTE, bits);
18157         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18158                                  HDA_AMP_MUTE, bits);
18159         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18160                                  HDA_AMP_MUTE, bits);
18161 }
18162
18163 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
18164 {
18165         unsigned int present;
18166         unsigned char bits;
18167
18168         present = snd_hda_jack_detect(codec, 0x15);
18169         bits = present ? HDA_AMP_MUTE : 0;
18170         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18171                                  HDA_AMP_MUTE, bits);
18172         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18173                                  HDA_AMP_MUTE, bits);
18174         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18175                                  HDA_AMP_MUTE, bits);
18176         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18177                                  HDA_AMP_MUTE, bits);
18178 }
18179
18180 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
18181 {
18182         unsigned int present;
18183         unsigned char bits;
18184
18185         present = snd_hda_jack_detect(codec, 0x1b);
18186         bits = present ? 0 : PIN_OUT;
18187         snd_hda_codec_write(codec, 0x14, 0,
18188                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
18189 }
18190
18191 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
18192 {
18193         unsigned int present1, present2;
18194
18195         present1 = snd_hda_jack_detect(codec, 0x21);
18196         present2 = snd_hda_jack_detect(codec, 0x15);
18197
18198         if (present1 || present2) {
18199                 snd_hda_codec_write_cache(codec, 0x14, 0,
18200                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18201         } else {
18202                 snd_hda_codec_write_cache(codec, 0x14, 0,
18203                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18204         }
18205 }
18206
18207 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
18208 {
18209         unsigned int present1, present2;
18210
18211         present1 = snd_hda_jack_detect(codec, 0x1b);
18212         present2 = snd_hda_jack_detect(codec, 0x15);
18213
18214         if (present1 || present2) {
18215                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18216                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
18217                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18218                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
18219         } else {
18220                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18221                                          HDA_AMP_MUTE, 0);
18222                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18223                                          HDA_AMP_MUTE, 0);
18224         }
18225 }
18226
18227 static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
18228 {
18229         unsigned int present1, present2;
18230
18231         present1 = snd_hda_codec_read(codec, 0x1b, 0,
18232                         AC_VERB_GET_PIN_SENSE, 0)
18233                         & AC_PINSENSE_PRESENCE;
18234         present2 = snd_hda_codec_read(codec, 0x21, 0,
18235                         AC_VERB_GET_PIN_SENSE, 0)
18236                         & AC_PINSENSE_PRESENCE;
18237
18238         if (present1 || present2) {
18239                 snd_hda_codec_write_cache(codec, 0x14, 0,
18240                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18241                 snd_hda_codec_write_cache(codec, 0x17, 0,
18242                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18243         } else {
18244                 snd_hda_codec_write_cache(codec, 0x14, 0,
18245                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18246                 snd_hda_codec_write_cache(codec, 0x17, 0,
18247                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18248         }
18249 }
18250
18251 static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
18252 {
18253         unsigned int present1, present2;
18254
18255         present1 = snd_hda_codec_read(codec, 0x21, 0,
18256                         AC_VERB_GET_PIN_SENSE, 0)
18257                         & AC_PINSENSE_PRESENCE;
18258         present2 = snd_hda_codec_read(codec, 0x15, 0,
18259                         AC_VERB_GET_PIN_SENSE, 0)
18260                         & AC_PINSENSE_PRESENCE;
18261
18262         if (present1 || present2) {
18263                 snd_hda_codec_write_cache(codec, 0x14, 0,
18264                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18265                 snd_hda_codec_write_cache(codec, 0x17, 0,
18266                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18267         } else {
18268                 snd_hda_codec_write_cache(codec, 0x14, 0,
18269                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18270                 snd_hda_codec_write_cache(codec, 0x17, 0,
18271                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18272         }
18273 }
18274
18275 static void alc663_m51va_unsol_event(struct hda_codec *codec,
18276                                            unsigned int res)
18277 {
18278         switch (res >> 26) {
18279         case ALC880_HP_EVENT:
18280                 alc663_m51va_speaker_automute(codec);
18281                 break;
18282         case ALC880_MIC_EVENT:
18283                 alc_mic_automute(codec);
18284                 break;
18285         }
18286 }
18287
18288 static void alc663_m51va_setup(struct hda_codec *codec)
18289 {
18290         struct alc_spec *spec = codec->spec;
18291         spec->ext_mic.pin = 0x18;
18292         spec->ext_mic.mux_idx = 0;
18293         spec->int_mic.pin = 0x12;
18294         spec->int_mic.mux_idx = 9;
18295         spec->auto_mic = 1;
18296 }
18297
18298 static void alc663_m51va_inithook(struct hda_codec *codec)
18299 {
18300         alc663_m51va_speaker_automute(codec);
18301         alc_mic_automute(codec);
18302 }
18303
18304 /* ***************** Mode1 ******************************/
18305 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
18306
18307 static void alc663_mode1_setup(struct hda_codec *codec)
18308 {
18309         struct alc_spec *spec = codec->spec;
18310         spec->ext_mic.pin = 0x18;
18311         spec->ext_mic.mux_idx = 0;
18312         spec->int_mic.pin = 0x19;
18313         spec->int_mic.mux_idx = 1;
18314         spec->auto_mic = 1;
18315 }
18316
18317 #define alc663_mode1_inithook           alc663_m51va_inithook
18318
18319 /* ***************** Mode2 ******************************/
18320 static void alc662_mode2_unsol_event(struct hda_codec *codec,
18321                                            unsigned int res)
18322 {
18323         switch (res >> 26) {
18324         case ALC880_HP_EVENT:
18325                 alc662_f5z_speaker_automute(codec);
18326                 break;
18327         case ALC880_MIC_EVENT:
18328                 alc_mic_automute(codec);
18329                 break;
18330         }
18331 }
18332
18333 #define alc662_mode2_setup      alc663_mode1_setup
18334
18335 static void alc662_mode2_inithook(struct hda_codec *codec)
18336 {
18337         alc662_f5z_speaker_automute(codec);
18338         alc_mic_automute(codec);
18339 }
18340 /* ***************** Mode3 ******************************/
18341 static void alc663_mode3_unsol_event(struct hda_codec *codec,
18342                                            unsigned int res)
18343 {
18344         switch (res >> 26) {
18345         case ALC880_HP_EVENT:
18346                 alc663_two_hp_m1_speaker_automute(codec);
18347                 break;
18348         case ALC880_MIC_EVENT:
18349                 alc_mic_automute(codec);
18350                 break;
18351         }
18352 }
18353
18354 #define alc663_mode3_setup      alc663_mode1_setup
18355
18356 static void alc663_mode3_inithook(struct hda_codec *codec)
18357 {
18358         alc663_two_hp_m1_speaker_automute(codec);
18359         alc_mic_automute(codec);
18360 }
18361 /* ***************** Mode4 ******************************/
18362 static void alc663_mode4_unsol_event(struct hda_codec *codec,
18363                                            unsigned int res)
18364 {
18365         switch (res >> 26) {
18366         case ALC880_HP_EVENT:
18367                 alc663_21jd_two_speaker_automute(codec);
18368                 break;
18369         case ALC880_MIC_EVENT:
18370                 alc_mic_automute(codec);
18371                 break;
18372         }
18373 }
18374
18375 #define alc663_mode4_setup      alc663_mode1_setup
18376
18377 static void alc663_mode4_inithook(struct hda_codec *codec)
18378 {
18379         alc663_21jd_two_speaker_automute(codec);
18380         alc_mic_automute(codec);
18381 }
18382 /* ***************** Mode5 ******************************/
18383 static void alc663_mode5_unsol_event(struct hda_codec *codec,
18384                                            unsigned int res)
18385 {
18386         switch (res >> 26) {
18387         case ALC880_HP_EVENT:
18388                 alc663_15jd_two_speaker_automute(codec);
18389                 break;
18390         case ALC880_MIC_EVENT:
18391                 alc_mic_automute(codec);
18392                 break;
18393         }
18394 }
18395
18396 #define alc663_mode5_setup      alc663_mode1_setup
18397
18398 static void alc663_mode5_inithook(struct hda_codec *codec)
18399 {
18400         alc663_15jd_two_speaker_automute(codec);
18401         alc_mic_automute(codec);
18402 }
18403 /* ***************** Mode6 ******************************/
18404 static void alc663_mode6_unsol_event(struct hda_codec *codec,
18405                                            unsigned int res)
18406 {
18407         switch (res >> 26) {
18408         case ALC880_HP_EVENT:
18409                 alc663_two_hp_m2_speaker_automute(codec);
18410                 break;
18411         case ALC880_MIC_EVENT:
18412                 alc_mic_automute(codec);
18413                 break;
18414         }
18415 }
18416
18417 #define alc663_mode6_setup      alc663_mode1_setup
18418
18419 static void alc663_mode6_inithook(struct hda_codec *codec)
18420 {
18421         alc663_two_hp_m2_speaker_automute(codec);
18422         alc_mic_automute(codec);
18423 }
18424
18425 /* ***************** Mode7 ******************************/
18426 static void alc663_mode7_unsol_event(struct hda_codec *codec,
18427                                            unsigned int res)
18428 {
18429         switch (res >> 26) {
18430         case ALC880_HP_EVENT:
18431                 alc663_two_hp_m7_speaker_automute(codec);
18432                 break;
18433         case ALC880_MIC_EVENT:
18434                 alc_mic_automute(codec);
18435                 break;
18436         }
18437 }
18438
18439 #define alc663_mode7_setup      alc663_mode1_setup
18440
18441 static void alc663_mode7_inithook(struct hda_codec *codec)
18442 {
18443         alc663_two_hp_m7_speaker_automute(codec);
18444         alc_mic_automute(codec);
18445 }
18446
18447 /* ***************** Mode8 ******************************/
18448 static void alc663_mode8_unsol_event(struct hda_codec *codec,
18449                                            unsigned int res)
18450 {
18451         switch (res >> 26) {
18452         case ALC880_HP_EVENT:
18453                 alc663_two_hp_m8_speaker_automute(codec);
18454                 break;
18455         case ALC880_MIC_EVENT:
18456                 alc_mic_automute(codec);
18457                 break;
18458         }
18459 }
18460
18461 #define alc663_mode8_setup      alc663_m51va_setup
18462
18463 static void alc663_mode8_inithook(struct hda_codec *codec)
18464 {
18465         alc663_two_hp_m8_speaker_automute(codec);
18466         alc_mic_automute(codec);
18467 }
18468
18469 static void alc663_g71v_hp_automute(struct hda_codec *codec)
18470 {
18471         unsigned int present;
18472         unsigned char bits;
18473
18474         present = snd_hda_jack_detect(codec, 0x21);
18475         bits = present ? HDA_AMP_MUTE : 0;
18476         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18477                                  HDA_AMP_MUTE, bits);
18478         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18479                                  HDA_AMP_MUTE, bits);
18480 }
18481
18482 static void alc663_g71v_front_automute(struct hda_codec *codec)
18483 {
18484         unsigned int present;
18485         unsigned char bits;
18486
18487         present = snd_hda_jack_detect(codec, 0x15);
18488         bits = present ? HDA_AMP_MUTE : 0;
18489         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18490                                  HDA_AMP_MUTE, bits);
18491 }
18492
18493 static void alc663_g71v_unsol_event(struct hda_codec *codec,
18494                                            unsigned int res)
18495 {
18496         switch (res >> 26) {
18497         case ALC880_HP_EVENT:
18498                 alc663_g71v_hp_automute(codec);
18499                 break;
18500         case ALC880_FRONT_EVENT:
18501                 alc663_g71v_front_automute(codec);
18502                 break;
18503         case ALC880_MIC_EVENT:
18504                 alc_mic_automute(codec);
18505                 break;
18506         }
18507 }
18508
18509 #define alc663_g71v_setup       alc663_m51va_setup
18510
18511 static void alc663_g71v_inithook(struct hda_codec *codec)
18512 {
18513         alc663_g71v_front_automute(codec);
18514         alc663_g71v_hp_automute(codec);
18515         alc_mic_automute(codec);
18516 }
18517
18518 static void alc663_g50v_unsol_event(struct hda_codec *codec,
18519                                            unsigned int res)
18520 {
18521         switch (res >> 26) {
18522         case ALC880_HP_EVENT:
18523                 alc663_m51va_speaker_automute(codec);
18524                 break;
18525         case ALC880_MIC_EVENT:
18526                 alc_mic_automute(codec);
18527                 break;
18528         }
18529 }
18530
18531 #define alc663_g50v_setup       alc663_m51va_setup
18532
18533 static void alc663_g50v_inithook(struct hda_codec *codec)
18534 {
18535         alc663_m51va_speaker_automute(codec);
18536         alc_mic_automute(codec);
18537 }
18538
18539 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
18540         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18541         ALC262_HIPPO_MASTER_SWITCH,
18542
18543         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
18544         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
18545         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
18546
18547         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
18548         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18549         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18550         { } /* end */
18551 };
18552
18553 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
18554         /* Master Playback automatically created from Speaker and Headphone */
18555         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18556         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
18557         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
18558         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
18559
18560         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
18561         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
18562         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
18563
18564         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18565         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18566         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
18567         { } /* end */
18568 };
18569
18570 #ifdef CONFIG_SND_HDA_POWER_SAVE
18571 #define alc662_loopbacks        alc880_loopbacks
18572 #endif
18573
18574
18575 /* pcm configuration: identical with ALC880 */
18576 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
18577 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
18578 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
18579 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
18580
18581 /*
18582  * configuration and preset
18583  */
18584 static const char *alc662_models[ALC662_MODEL_LAST] = {
18585         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
18586         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
18587         [ALC662_3ST_6ch]        = "3stack-6ch",
18588         [ALC662_5ST_DIG]        = "6stack-dig",
18589         [ALC662_LENOVO_101E]    = "lenovo-101e",
18590         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
18591         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
18592         [ALC662_ECS] = "ecs",
18593         [ALC663_ASUS_M51VA] = "m51va",
18594         [ALC663_ASUS_G71V] = "g71v",
18595         [ALC663_ASUS_H13] = "h13",
18596         [ALC663_ASUS_G50V] = "g50v",
18597         [ALC663_ASUS_MODE1] = "asus-mode1",
18598         [ALC662_ASUS_MODE2] = "asus-mode2",
18599         [ALC663_ASUS_MODE3] = "asus-mode3",
18600         [ALC663_ASUS_MODE4] = "asus-mode4",
18601         [ALC663_ASUS_MODE5] = "asus-mode5",
18602         [ALC663_ASUS_MODE6] = "asus-mode6",
18603         [ALC663_ASUS_MODE7] = "asus-mode7",
18604         [ALC663_ASUS_MODE8] = "asus-mode8",
18605         [ALC272_DELL]           = "dell",
18606         [ALC272_DELL_ZM1]       = "dell-zm1",
18607         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
18608         [ALC662_AUTO]           = "auto",
18609 };
18610
18611 static struct snd_pci_quirk alc662_cfg_tbl[] = {
18612         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
18613         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
18614         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
18615         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
18616         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
18617         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
18618         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
18619         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
18620         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
18621         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
18622         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
18623         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
18624         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
18625         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
18626         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
18627         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
18628         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
18629         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
18630         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
18631         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
18632         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
18633         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
18634         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
18635         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
18636         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
18637         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
18638         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
18639         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
18640         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
18641         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
18642         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
18643         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
18644         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
18645         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
18646         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
18647         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
18648         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
18649         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
18650         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
18651         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
18652         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
18653         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
18654         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
18655         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
18656         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
18657         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
18658         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
18659         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
18660         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
18661         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
18662         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
18663         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
18664         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
18665         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
18666         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
18667         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
18668         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
18669         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
18670         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
18671         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
18672         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
18673         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
18674         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
18675         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
18676                       ALC662_3ST_6ch_DIG),
18677         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
18678         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
18679         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
18680                       ALC662_3ST_6ch_DIG),
18681         SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
18682         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
18683         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
18684         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
18685         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
18686                                         ALC662_3ST_6ch_DIG),
18687         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
18688                            ALC663_ASUS_H13),
18689         {}
18690 };
18691
18692 static struct alc_config_preset alc662_presets[] = {
18693         [ALC662_3ST_2ch_DIG] = {
18694                 .mixers = { alc662_3ST_2ch_mixer },
18695                 .init_verbs = { alc662_init_verbs },
18696                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18697                 .dac_nids = alc662_dac_nids,
18698                 .dig_out_nid = ALC662_DIGOUT_NID,
18699                 .dig_in_nid = ALC662_DIGIN_NID,
18700                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18701                 .channel_mode = alc662_3ST_2ch_modes,
18702                 .input_mux = &alc662_capture_source,
18703         },
18704         [ALC662_3ST_6ch_DIG] = {
18705                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18706                 .init_verbs = { alc662_init_verbs },
18707                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18708                 .dac_nids = alc662_dac_nids,
18709                 .dig_out_nid = ALC662_DIGOUT_NID,
18710                 .dig_in_nid = ALC662_DIGIN_NID,
18711                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18712                 .channel_mode = alc662_3ST_6ch_modes,
18713                 .need_dac_fix = 1,
18714                 .input_mux = &alc662_capture_source,
18715         },
18716         [ALC662_3ST_6ch] = {
18717                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18718                 .init_verbs = { alc662_init_verbs },
18719                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18720                 .dac_nids = alc662_dac_nids,
18721                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18722                 .channel_mode = alc662_3ST_6ch_modes,
18723                 .need_dac_fix = 1,
18724                 .input_mux = &alc662_capture_source,
18725         },
18726         [ALC662_5ST_DIG] = {
18727                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
18728                 .init_verbs = { alc662_init_verbs },
18729                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18730                 .dac_nids = alc662_dac_nids,
18731                 .dig_out_nid = ALC662_DIGOUT_NID,
18732                 .dig_in_nid = ALC662_DIGIN_NID,
18733                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
18734                 .channel_mode = alc662_5stack_modes,
18735                 .input_mux = &alc662_capture_source,
18736         },
18737         [ALC662_LENOVO_101E] = {
18738                 .mixers = { alc662_lenovo_101e_mixer },
18739                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
18740                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18741                 .dac_nids = alc662_dac_nids,
18742                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18743                 .channel_mode = alc662_3ST_2ch_modes,
18744                 .input_mux = &alc662_lenovo_101e_capture_source,
18745                 .unsol_event = alc662_lenovo_101e_unsol_event,
18746                 .init_hook = alc662_lenovo_101e_all_automute,
18747         },
18748         [ALC662_ASUS_EEEPC_P701] = {
18749                 .mixers = { alc662_eeepc_p701_mixer },
18750                 .init_verbs = { alc662_init_verbs,
18751                                 alc662_eeepc_sue_init_verbs },
18752                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18753                 .dac_nids = alc662_dac_nids,
18754                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18755                 .channel_mode = alc662_3ST_2ch_modes,
18756                 .unsol_event = alc662_eeepc_unsol_event,
18757                 .setup = alc662_eeepc_setup,
18758                 .init_hook = alc662_eeepc_inithook,
18759         },
18760         [ALC662_ASUS_EEEPC_EP20] = {
18761                 .mixers = { alc662_eeepc_ep20_mixer,
18762                             alc662_chmode_mixer },
18763                 .init_verbs = { alc662_init_verbs,
18764                                 alc662_eeepc_ep20_sue_init_verbs },
18765                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18766                 .dac_nids = alc662_dac_nids,
18767                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18768                 .channel_mode = alc662_3ST_6ch_modes,
18769                 .input_mux = &alc662_lenovo_101e_capture_source,
18770                 .unsol_event = alc662_eeepc_unsol_event,
18771                 .setup = alc662_eeepc_ep20_setup,
18772                 .init_hook = alc662_eeepc_ep20_inithook,
18773         },
18774         [ALC662_ECS] = {
18775                 .mixers = { alc662_ecs_mixer },
18776                 .init_verbs = { alc662_init_verbs,
18777                                 alc662_ecs_init_verbs },
18778                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18779                 .dac_nids = alc662_dac_nids,
18780                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18781                 .channel_mode = alc662_3ST_2ch_modes,
18782                 .unsol_event = alc662_eeepc_unsol_event,
18783                 .setup = alc662_eeepc_setup,
18784                 .init_hook = alc662_eeepc_inithook,
18785         },
18786         [ALC663_ASUS_M51VA] = {
18787                 .mixers = { alc663_m51va_mixer },
18788                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18789                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18790                 .dac_nids = alc662_dac_nids,
18791                 .dig_out_nid = ALC662_DIGOUT_NID,
18792                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18793                 .channel_mode = alc662_3ST_2ch_modes,
18794                 .unsol_event = alc663_m51va_unsol_event,
18795                 .setup = alc663_m51va_setup,
18796                 .init_hook = alc663_m51va_inithook,
18797         },
18798         [ALC663_ASUS_G71V] = {
18799                 .mixers = { alc663_g71v_mixer },
18800                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
18801                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18802                 .dac_nids = alc662_dac_nids,
18803                 .dig_out_nid = ALC662_DIGOUT_NID,
18804                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18805                 .channel_mode = alc662_3ST_2ch_modes,
18806                 .unsol_event = alc663_g71v_unsol_event,
18807                 .setup = alc663_g71v_setup,
18808                 .init_hook = alc663_g71v_inithook,
18809         },
18810         [ALC663_ASUS_H13] = {
18811                 .mixers = { alc663_m51va_mixer },
18812                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18813                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18814                 .dac_nids = alc662_dac_nids,
18815                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18816                 .channel_mode = alc662_3ST_2ch_modes,
18817                 .unsol_event = alc663_m51va_unsol_event,
18818                 .init_hook = alc663_m51va_inithook,
18819         },
18820         [ALC663_ASUS_G50V] = {
18821                 .mixers = { alc663_g50v_mixer },
18822                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
18823                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18824                 .dac_nids = alc662_dac_nids,
18825                 .dig_out_nid = ALC662_DIGOUT_NID,
18826                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18827                 .channel_mode = alc662_3ST_6ch_modes,
18828                 .input_mux = &alc663_capture_source,
18829                 .unsol_event = alc663_g50v_unsol_event,
18830                 .setup = alc663_g50v_setup,
18831                 .init_hook = alc663_g50v_inithook,
18832         },
18833         [ALC663_ASUS_MODE1] = {
18834                 .mixers = { alc663_m51va_mixer },
18835                 .cap_mixer = alc662_auto_capture_mixer,
18836                 .init_verbs = { alc662_init_verbs,
18837                                 alc663_21jd_amic_init_verbs },
18838                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18839                 .hp_nid = 0x03,
18840                 .dac_nids = alc662_dac_nids,
18841                 .dig_out_nid = ALC662_DIGOUT_NID,
18842                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18843                 .channel_mode = alc662_3ST_2ch_modes,
18844                 .unsol_event = alc663_mode1_unsol_event,
18845                 .setup = alc663_mode1_setup,
18846                 .init_hook = alc663_mode1_inithook,
18847         },
18848         [ALC662_ASUS_MODE2] = {
18849                 .mixers = { alc662_1bjd_mixer },
18850                 .cap_mixer = alc662_auto_capture_mixer,
18851                 .init_verbs = { alc662_init_verbs,
18852                                 alc662_1bjd_amic_init_verbs },
18853                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18854                 .dac_nids = alc662_dac_nids,
18855                 .dig_out_nid = ALC662_DIGOUT_NID,
18856                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18857                 .channel_mode = alc662_3ST_2ch_modes,
18858                 .unsol_event = alc662_mode2_unsol_event,
18859                 .setup = alc662_mode2_setup,
18860                 .init_hook = alc662_mode2_inithook,
18861         },
18862         [ALC663_ASUS_MODE3] = {
18863                 .mixers = { alc663_two_hp_m1_mixer },
18864                 .cap_mixer = alc662_auto_capture_mixer,
18865                 .init_verbs = { alc662_init_verbs,
18866                                 alc663_two_hp_amic_m1_init_verbs },
18867                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18868                 .hp_nid = 0x03,
18869                 .dac_nids = alc662_dac_nids,
18870                 .dig_out_nid = ALC662_DIGOUT_NID,
18871                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18872                 .channel_mode = alc662_3ST_2ch_modes,
18873                 .unsol_event = alc663_mode3_unsol_event,
18874                 .setup = alc663_mode3_setup,
18875                 .init_hook = alc663_mode3_inithook,
18876         },
18877         [ALC663_ASUS_MODE4] = {
18878                 .mixers = { alc663_asus_21jd_clfe_mixer },
18879                 .cap_mixer = alc662_auto_capture_mixer,
18880                 .init_verbs = { alc662_init_verbs,
18881                                 alc663_21jd_amic_init_verbs},
18882                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18883                 .hp_nid = 0x03,
18884                 .dac_nids = alc662_dac_nids,
18885                 .dig_out_nid = ALC662_DIGOUT_NID,
18886                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18887                 .channel_mode = alc662_3ST_2ch_modes,
18888                 .unsol_event = alc663_mode4_unsol_event,
18889                 .setup = alc663_mode4_setup,
18890                 .init_hook = alc663_mode4_inithook,
18891         },
18892         [ALC663_ASUS_MODE5] = {
18893                 .mixers = { alc663_asus_15jd_clfe_mixer },
18894                 .cap_mixer = alc662_auto_capture_mixer,
18895                 .init_verbs = { alc662_init_verbs,
18896                                 alc663_15jd_amic_init_verbs },
18897                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18898                 .hp_nid = 0x03,
18899                 .dac_nids = alc662_dac_nids,
18900                 .dig_out_nid = ALC662_DIGOUT_NID,
18901                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18902                 .channel_mode = alc662_3ST_2ch_modes,
18903                 .unsol_event = alc663_mode5_unsol_event,
18904                 .setup = alc663_mode5_setup,
18905                 .init_hook = alc663_mode5_inithook,
18906         },
18907         [ALC663_ASUS_MODE6] = {
18908                 .mixers = { alc663_two_hp_m2_mixer },
18909                 .cap_mixer = alc662_auto_capture_mixer,
18910                 .init_verbs = { alc662_init_verbs,
18911                                 alc663_two_hp_amic_m2_init_verbs },
18912                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18913                 .hp_nid = 0x03,
18914                 .dac_nids = alc662_dac_nids,
18915                 .dig_out_nid = ALC662_DIGOUT_NID,
18916                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18917                 .channel_mode = alc662_3ST_2ch_modes,
18918                 .unsol_event = alc663_mode6_unsol_event,
18919                 .setup = alc663_mode6_setup,
18920                 .init_hook = alc663_mode6_inithook,
18921         },
18922         [ALC663_ASUS_MODE7] = {
18923                 .mixers = { alc663_mode7_mixer },
18924                 .cap_mixer = alc662_auto_capture_mixer,
18925                 .init_verbs = { alc662_init_verbs,
18926                                 alc663_mode7_init_verbs },
18927                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18928                 .hp_nid = 0x03,
18929                 .dac_nids = alc662_dac_nids,
18930                 .dig_out_nid = ALC662_DIGOUT_NID,
18931                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18932                 .channel_mode = alc662_3ST_2ch_modes,
18933                 .unsol_event = alc663_mode7_unsol_event,
18934                 .setup = alc663_mode7_setup,
18935                 .init_hook = alc663_mode7_inithook,
18936         },
18937         [ALC663_ASUS_MODE8] = {
18938                 .mixers = { alc663_mode8_mixer },
18939                 .cap_mixer = alc662_auto_capture_mixer,
18940                 .init_verbs = { alc662_init_verbs,
18941                                 alc663_mode8_init_verbs },
18942                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18943                 .hp_nid = 0x03,
18944                 .dac_nids = alc662_dac_nids,
18945                 .dig_out_nid = ALC662_DIGOUT_NID,
18946                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18947                 .channel_mode = alc662_3ST_2ch_modes,
18948                 .unsol_event = alc663_mode8_unsol_event,
18949                 .setup = alc663_mode8_setup,
18950                 .init_hook = alc663_mode8_inithook,
18951         },
18952         [ALC272_DELL] = {
18953                 .mixers = { alc663_m51va_mixer },
18954                 .cap_mixer = alc272_auto_capture_mixer,
18955                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
18956                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18957                 .dac_nids = alc662_dac_nids,
18958                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18959                 .adc_nids = alc272_adc_nids,
18960                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
18961                 .capsrc_nids = alc272_capsrc_nids,
18962                 .channel_mode = alc662_3ST_2ch_modes,
18963                 .unsol_event = alc663_m51va_unsol_event,
18964                 .setup = alc663_m51va_setup,
18965                 .init_hook = alc663_m51va_inithook,
18966         },
18967         [ALC272_DELL_ZM1] = {
18968                 .mixers = { alc663_m51va_mixer },
18969                 .cap_mixer = alc662_auto_capture_mixer,
18970                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
18971                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18972                 .dac_nids = alc662_dac_nids,
18973                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18974                 .adc_nids = alc662_adc_nids,
18975                 .num_adc_nids = 1,
18976                 .capsrc_nids = alc662_capsrc_nids,
18977                 .channel_mode = alc662_3ST_2ch_modes,
18978                 .unsol_event = alc663_m51va_unsol_event,
18979                 .setup = alc663_m51va_setup,
18980                 .init_hook = alc663_m51va_inithook,
18981         },
18982         [ALC272_SAMSUNG_NC10] = {
18983                 .mixers = { alc272_nc10_mixer },
18984                 .init_verbs = { alc662_init_verbs,
18985                                 alc663_21jd_amic_init_verbs },
18986                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18987                 .dac_nids = alc272_dac_nids,
18988                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18989                 .channel_mode = alc662_3ST_2ch_modes,
18990                 /*.input_mux = &alc272_nc10_capture_source,*/
18991                 .unsol_event = alc663_mode4_unsol_event,
18992                 .setup = alc663_mode4_setup,
18993                 .init_hook = alc663_mode4_inithook,
18994         },
18995 };
18996
18997
18998 /*
18999  * BIOS auto configuration
19000  */
19001
19002 /* convert from MIX nid to DAC */
19003 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
19004 {
19005         if (nid == 0x0f)
19006                 return 0x02;
19007         else if (nid >= 0x0c && nid <= 0x0e)
19008                 return nid - 0x0c + 0x02;
19009         else if (nid == 0x26) /* ALC887-VD has this DAC too */
19010                 return 0x25;
19011         else
19012                 return 0;
19013 }
19014
19015 /* get MIX nid connected to the given pin targeted to DAC */
19016 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
19017                                    hda_nid_t dac)
19018 {
19019         hda_nid_t mix[5];
19020         int i, num;
19021
19022         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
19023         for (i = 0; i < num; i++) {
19024                 if (alc662_mix_to_dac(mix[i]) == dac)
19025                         return mix[i];
19026         }
19027         return 0;
19028 }
19029
19030 /* look for an empty DAC slot */
19031 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
19032 {
19033         struct alc_spec *spec = codec->spec;
19034         hda_nid_t srcs[5];
19035         int i, j, num;
19036
19037         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
19038         if (num < 0)
19039                 return 0;
19040         for (i = 0; i < num; i++) {
19041                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
19042                 if (!nid)
19043                         continue;
19044                 for (j = 0; j < spec->multiout.num_dacs; j++)
19045                         if (spec->multiout.dac_nids[j] == nid)
19046                                 break;
19047                 if (j >= spec->multiout.num_dacs)
19048                         return nid;
19049         }
19050         return 0;
19051 }
19052
19053 /* fill in the dac_nids table from the parsed pin configuration */
19054 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
19055                                      const struct auto_pin_cfg *cfg)
19056 {
19057         struct alc_spec *spec = codec->spec;
19058         int i;
19059         hda_nid_t dac;
19060
19061         spec->multiout.dac_nids = spec->private_dac_nids;
19062         for (i = 0; i < cfg->line_outs; i++) {
19063                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
19064                 if (!dac)
19065                         continue;
19066                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19067         }
19068         return 0;
19069 }
19070
19071 static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
19072                               hda_nid_t nid, unsigned int chs)
19073 {
19074         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
19075                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
19076 }
19077
19078 static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
19079                              hda_nid_t nid, unsigned int chs)
19080 {
19081         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19082                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
19083 }
19084
19085 #define alc662_add_stereo_vol(spec, pfx, nid) \
19086         alc662_add_vol_ctl(spec, pfx, nid, 3)
19087 #define alc662_add_stereo_sw(spec, pfx, nid) \
19088         alc662_add_sw_ctl(spec, pfx, nid, 3)
19089
19090 /* add playback controls from the parsed DAC table */
19091 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
19092                                              const struct auto_pin_cfg *cfg)
19093 {
19094         struct alc_spec *spec = codec->spec;
19095         static const char *chname[4] = {
19096                 "Front", "Surround", NULL /*CLFE*/, "Side"
19097         };
19098         hda_nid_t nid, mix;
19099         int i, err;
19100
19101         for (i = 0; i < cfg->line_outs; i++) {
19102                 nid = spec->multiout.dac_nids[i];
19103                 if (!nid)
19104                         continue;
19105                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
19106                 if (!mix)
19107                         continue;
19108                 if (i == 2) {
19109                         /* Center/LFE */
19110                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
19111                         if (err < 0)
19112                                 return err;
19113                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
19114                         if (err < 0)
19115                                 return err;
19116                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
19117                         if (err < 0)
19118                                 return err;
19119                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
19120                         if (err < 0)
19121                                 return err;
19122                 } else {
19123                         const char *pfx;
19124                         if (cfg->line_outs == 1 &&
19125                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
19126                                 if (cfg->hp_outs)
19127                                         pfx = "Speaker";
19128                                 else
19129                                         pfx = "PCM";
19130                         } else
19131                                 pfx = chname[i];
19132                         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19133                         if (err < 0)
19134                                 return err;
19135                         if (cfg->line_outs == 1 &&
19136                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19137                                 pfx = "Speaker";
19138                         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19139                         if (err < 0)
19140                                 return err;
19141                 }
19142         }
19143         return 0;
19144 }
19145
19146 /* add playback controls for speaker and HP outputs */
19147 /* return DAC nid if any new DAC is assigned */
19148 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
19149                                         const char *pfx)
19150 {
19151         struct alc_spec *spec = codec->spec;
19152         hda_nid_t nid, mix;
19153         int err;
19154
19155         if (!pin)
19156                 return 0;
19157         nid = alc662_look_for_dac(codec, pin);
19158         if (!nid) {
19159                 /* the corresponding DAC is already occupied */
19160                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
19161                         return 0; /* no way */
19162                 /* create a switch only */
19163                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19164                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
19165         }
19166
19167         mix = alc662_dac_to_mix(codec, pin, nid);
19168         if (!mix)
19169                 return 0;
19170         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19171         if (err < 0)
19172                 return err;
19173         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19174         if (err < 0)
19175                 return err;
19176         return nid;
19177 }
19178
19179 /* create playback/capture controls for input pins */
19180 #define alc662_auto_create_input_ctls \
19181         alc882_auto_create_input_ctls
19182
19183 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
19184                                               hda_nid_t nid, int pin_type,
19185                                               hda_nid_t dac)
19186 {
19187         int i, num;
19188         hda_nid_t srcs[HDA_MAX_CONNECTIONS];
19189
19190         alc_set_pin_output(codec, nid, pin_type);
19191         /* need the manual connection? */
19192         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
19193         if (num <= 1)
19194                 return;
19195         for (i = 0; i < num; i++) {
19196                 if (alc662_mix_to_dac(srcs[i]) != dac)
19197                         continue;
19198                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
19199                 return;
19200         }
19201 }
19202
19203 static void alc662_auto_init_multi_out(struct hda_codec *codec)
19204 {
19205         struct alc_spec *spec = codec->spec;
19206         int pin_type = get_pin_type(spec->autocfg.line_out_type);
19207         int i;
19208
19209         for (i = 0; i <= HDA_SIDE; i++) {
19210                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
19211                 if (nid)
19212                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
19213                                         spec->multiout.dac_nids[i]);
19214         }
19215 }
19216
19217 static void alc662_auto_init_hp_out(struct hda_codec *codec)
19218 {
19219         struct alc_spec *spec = codec->spec;
19220         hda_nid_t pin;
19221
19222         pin = spec->autocfg.hp_pins[0];
19223         if (pin)
19224                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
19225                                                   spec->multiout.hp_nid);
19226         pin = spec->autocfg.speaker_pins[0];
19227         if (pin)
19228                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
19229                                         spec->multiout.extra_out_nid[0]);
19230 }
19231
19232 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
19233
19234 static void alc662_auto_init_analog_input(struct hda_codec *codec)
19235 {
19236         struct alc_spec *spec = codec->spec;
19237         struct auto_pin_cfg *cfg = &spec->autocfg;
19238         int i;
19239
19240         for (i = 0; i < cfg->num_inputs; i++) {
19241                 hda_nid_t nid = cfg->inputs[i].pin;
19242                 if (alc_is_input_pin(codec, nid)) {
19243                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
19244                         if (nid != ALC662_PIN_CD_NID &&
19245                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
19246                                 snd_hda_codec_write(codec, nid, 0,
19247                                                     AC_VERB_SET_AMP_GAIN_MUTE,
19248                                                     AMP_OUT_MUTE);
19249                 }
19250         }
19251 }
19252
19253 #define alc662_auto_init_input_src      alc882_auto_init_input_src
19254
19255 static int alc662_parse_auto_config(struct hda_codec *codec)
19256 {
19257         struct alc_spec *spec = codec->spec;
19258         int err;
19259         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
19260
19261         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19262                                            alc662_ignore);
19263         if (err < 0)
19264                 return err;
19265         if (!spec->autocfg.line_outs)
19266                 return 0; /* can't find valid BIOS pin config */
19267
19268         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
19269         if (err < 0)
19270                 return err;
19271         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
19272         if (err < 0)
19273                 return err;
19274         err = alc662_auto_create_extra_out(codec,
19275                                            spec->autocfg.speaker_pins[0],
19276                                            "Speaker");
19277         if (err < 0)
19278                 return err;
19279         if (err)
19280                 spec->multiout.extra_out_nid[0] = err;
19281         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
19282                                            "Headphone");
19283         if (err < 0)
19284                 return err;
19285         if (err)
19286                 spec->multiout.hp_nid = err;
19287         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
19288         if (err < 0)
19289                 return err;
19290
19291         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
19292
19293         alc_auto_parse_digital(codec);
19294
19295         if (spec->kctls.list)
19296                 add_mixer(spec, spec->kctls.list);
19297
19298         spec->num_mux_defs = 1;
19299         spec->input_mux = &spec->private_imux[0];
19300
19301         add_verb(spec, alc662_init_verbs);
19302         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19303             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19304                 add_verb(spec, alc663_init_verbs);
19305
19306         if (codec->vendor_id == 0x10ec0272)
19307                 add_verb(spec, alc272_init_verbs);
19308
19309         err = alc_auto_add_mic_boost(codec);
19310         if (err < 0)
19311                 return err;
19312
19313         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19314             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19315             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
19316         else
19317             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
19318
19319         return 1;
19320 }
19321
19322 /* additional initialization for auto-configuration model */
19323 static void alc662_auto_init(struct hda_codec *codec)
19324 {
19325         struct alc_spec *spec = codec->spec;
19326         alc662_auto_init_multi_out(codec);
19327         alc662_auto_init_hp_out(codec);
19328         alc662_auto_init_analog_input(codec);
19329         alc662_auto_init_input_src(codec);
19330         alc_auto_init_digital(codec);
19331         if (spec->unsol_event)
19332                 alc_inithook(codec);
19333 }
19334
19335 static void alc272_fixup_mario(struct hda_codec *codec,
19336                                const struct alc_fixup *fix, int pre_init) {
19337         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
19338                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
19339                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
19340                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
19341                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
19342                 printk(KERN_WARNING
19343                        "hda_codec: failed to override amp caps for NID 0x2\n");
19344 }
19345
19346 enum {
19347         ALC662_FIXUP_ASPIRE,
19348         ALC662_FIXUP_IDEAPAD,
19349         ALC272_FIXUP_MARIO,
19350 };
19351
19352 static const struct alc_fixup alc662_fixups[] = {
19353         [ALC662_FIXUP_ASPIRE] = {
19354                 .pins = (const struct alc_pincfg[]) {
19355                         { 0x15, 0x99130112 }, /* subwoofer */
19356                         { }
19357                 }
19358         },
19359         [ALC662_FIXUP_IDEAPAD] = {
19360                 .pins = (const struct alc_pincfg[]) {
19361                         { 0x17, 0x99130112 }, /* subwoofer */
19362                         { }
19363                 }
19364         },
19365         [ALC272_FIXUP_MARIO] = {
19366                 .func = alc272_fixup_mario,
19367         }
19368 };
19369
19370 static struct snd_pci_quirk alc662_fixup_tbl[] = {
19371         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
19372         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
19373         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
19374         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
19375         {}
19376 };
19377
19378 static const struct alc_model_fixup alc662_fixup_models[] = {
19379         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
19380         {}
19381 };
19382
19383
19384 static int patch_alc662(struct hda_codec *codec)
19385 {
19386         struct alc_spec *spec;
19387         int err, board_config;
19388         int coef;
19389
19390         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19391         if (!spec)
19392                 return -ENOMEM;
19393
19394         codec->spec = spec;
19395
19396         alc_auto_parse_customize_define(codec);
19397
19398         alc_fix_pll_init(codec, 0x20, 0x04, 15);
19399
19400         coef = alc_read_coef_idx(codec, 0);
19401         if (coef == 0x8020 || coef == 0x8011)
19402                 alc_codec_rename(codec, "ALC661");
19403         else if (coef & (1 << 14) &&
19404                 codec->bus->pci->subsystem_vendor == 0x1025 &&
19405                 spec->cdefine.platform_type == 1)
19406                 alc_codec_rename(codec, "ALC272X");
19407         else if (coef == 0x4011)
19408                 alc_codec_rename(codec, "ALC656");
19409
19410         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
19411                                                   alc662_models,
19412                                                   alc662_cfg_tbl);
19413         if (board_config < 0) {
19414                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19415                        codec->chip_name);
19416                 board_config = ALC662_AUTO;
19417         }
19418
19419         if (board_config == ALC662_AUTO) {
19420                 alc_pick_fixup(codec, alc662_fixup_tbl, alc662_fixups, 1);
19421                 /* automatic parse from the BIOS config */
19422                 err = alc662_parse_auto_config(codec);
19423                 if (err < 0) {
19424                         alc_free(codec);
19425                         return err;
19426                 } else if (!err) {
19427                         printk(KERN_INFO
19428                                "hda_codec: Cannot set up configuration "
19429                                "from BIOS.  Using base mode...\n");
19430                         board_config = ALC662_3ST_2ch_DIG;
19431                 }
19432         }
19433
19434         if (has_cdefine_beep(codec)) {
19435                 err = snd_hda_attach_beep_device(codec, 0x1);
19436                 if (err < 0) {
19437                         alc_free(codec);
19438                         return err;
19439                 }
19440         }
19441
19442         if (board_config != ALC662_AUTO)
19443                 setup_preset(codec, &alc662_presets[board_config]);
19444
19445         spec->stream_analog_playback = &alc662_pcm_analog_playback;
19446         spec->stream_analog_capture = &alc662_pcm_analog_capture;
19447
19448         spec->stream_digital_playback = &alc662_pcm_digital_playback;
19449         spec->stream_digital_capture = &alc662_pcm_digital_capture;
19450
19451         if (!spec->adc_nids) {
19452                 spec->adc_nids = alc662_adc_nids;
19453                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
19454         }
19455         if (!spec->capsrc_nids)
19456                 spec->capsrc_nids = alc662_capsrc_nids;
19457
19458         if (!spec->cap_mixer)
19459                 set_capture_mixer(codec);
19460
19461         if (has_cdefine_beep(codec)) {
19462                 switch (codec->vendor_id) {
19463                 case 0x10ec0662:
19464                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
19465                         break;
19466                 case 0x10ec0272:
19467                 case 0x10ec0663:
19468                 case 0x10ec0665:
19469                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
19470                         break;
19471                 case 0x10ec0273:
19472                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
19473                         break;
19474                 }
19475         }
19476         spec->vmaster_nid = 0x02;
19477
19478         codec->patch_ops = alc_patch_ops;
19479         if (board_config == ALC662_AUTO) {
19480                 spec->init_hook = alc662_auto_init;
19481                 alc_pick_fixup_model(codec, alc662_fixup_models,
19482                                      alc662_fixup_tbl, alc662_fixups, 0);
19483         }
19484
19485         alc_init_jacks(codec);
19486
19487 #ifdef CONFIG_SND_HDA_POWER_SAVE
19488         if (!spec->loopback.amplist)
19489                 spec->loopback.amplist = alc662_loopbacks;
19490 #endif
19491
19492         return 0;
19493 }
19494
19495 static int patch_alc888(struct hda_codec *codec)
19496 {
19497         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
19498                 kfree(codec->chip_name);
19499                 if (codec->vendor_id == 0x10ec0887)
19500                         codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL);
19501                 else
19502                         codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
19503                 if (!codec->chip_name) {
19504                         alc_free(codec);
19505                         return -ENOMEM;
19506                 }
19507                 return patch_alc662(codec);
19508         }
19509         return patch_alc882(codec);
19510 }
19511
19512 /*
19513  * ALC680 support
19514  */
19515 #define ALC680_DIGIN_NID        ALC880_DIGIN_NID
19516 #define ALC680_DIGOUT_NID       ALC880_DIGOUT_NID
19517 #define alc680_modes            alc260_modes
19518
19519 static hda_nid_t alc680_dac_nids[3] = {
19520         /* Lout1, Lout2, hp */
19521         0x02, 0x03, 0x04
19522 };
19523
19524 static hda_nid_t alc680_adc_nids[3] = {
19525         /* ADC0-2 */
19526         /* DMIC, MIC, Line-in*/
19527         0x07, 0x08, 0x09
19528 };
19529
19530 /*
19531  * Analog capture ADC cgange
19532  */
19533 static void alc680_rec_autoswitch(struct hda_codec *codec)
19534 {
19535         struct alc_spec *spec = codec->spec;
19536         struct auto_pin_cfg *cfg = &spec->autocfg;
19537         int pin_found = 0;
19538         int type_found = AUTO_PIN_LAST;
19539         hda_nid_t nid;
19540         int i;
19541
19542         for (i = 0; i < cfg->num_inputs; i++) {
19543                 nid = cfg->inputs[i].pin;
19544                 if (!(snd_hda_query_pin_caps(codec, nid) &
19545                       AC_PINCAP_PRES_DETECT))
19546                         continue;
19547                 if (snd_hda_jack_detect(codec, nid)) {
19548                         if (cfg->inputs[i].type < type_found) {
19549                                 type_found = cfg->inputs[i].type;
19550                                 pin_found = nid;
19551                         }
19552                 }
19553         }
19554
19555         nid = 0x07;
19556         if (pin_found)
19557                 snd_hda_get_connections(codec, pin_found, &nid, 1);
19558
19559         if (nid != spec->cur_adc)
19560                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
19561         spec->cur_adc = nid;
19562         snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0,
19563                                    spec->cur_adc_format);
19564 }
19565
19566 static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
19567                                       struct hda_codec *codec,
19568                                       unsigned int stream_tag,
19569                                       unsigned int format,
19570                                       struct snd_pcm_substream *substream)
19571 {
19572         struct alc_spec *spec = codec->spec;
19573
19574         spec->cur_adc = 0x07;
19575         spec->cur_adc_stream_tag = stream_tag;
19576         spec->cur_adc_format = format;
19577
19578         alc680_rec_autoswitch(codec);
19579         return 0;
19580 }
19581
19582 static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
19583                                       struct hda_codec *codec,
19584                                       struct snd_pcm_substream *substream)
19585 {
19586         snd_hda_codec_cleanup_stream(codec, 0x07);
19587         snd_hda_codec_cleanup_stream(codec, 0x08);
19588         snd_hda_codec_cleanup_stream(codec, 0x09);
19589         return 0;
19590 }
19591
19592 static struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
19593         .substreams = 1, /* can be overridden */
19594         .channels_min = 2,
19595         .channels_max = 2,
19596         /* NID is set in alc_build_pcms */
19597         .ops = {
19598                 .prepare = alc680_capture_pcm_prepare,
19599                 .cleanup = alc680_capture_pcm_cleanup
19600         },
19601 };
19602
19603 static struct snd_kcontrol_new alc680_base_mixer[] = {
19604         /* output mixer control */
19605         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
19606         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
19607         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
19608         HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
19609         HDA_CODEC_VOLUME("Int Mic Boost", 0x12, 0, HDA_INPUT),
19610         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
19611         HDA_CODEC_VOLUME("Line In Boost", 0x19, 0, HDA_INPUT),
19612         { }
19613 };
19614
19615 static struct hda_bind_ctls alc680_bind_cap_vol = {
19616         .ops = &snd_hda_bind_vol,
19617         .values = {
19618                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19619                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19620                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19621                 0
19622         },
19623 };
19624
19625 static struct hda_bind_ctls alc680_bind_cap_switch = {
19626         .ops = &snd_hda_bind_sw,
19627         .values = {
19628                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19629                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19630                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19631                 0
19632         },
19633 };
19634
19635 static struct snd_kcontrol_new alc680_master_capture_mixer[] = {
19636         HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
19637         HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
19638         { } /* end */
19639 };
19640
19641 /*
19642  * generic initialization of ADC, input mixers and output mixers
19643  */
19644 static struct hda_verb alc680_init_verbs[] = {
19645         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19646         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19647         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19648
19649         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19650         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19651         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19652         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
19653         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
19654         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19655
19656         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19657         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19658         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19659         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19660         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19661
19662         {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT   | AC_USRSP_EN},
19663         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19664         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19665
19666         { }
19667 };
19668
19669 /* toggle speaker-output according to the hp-jack state */
19670 static void alc680_base_setup(struct hda_codec *codec)
19671 {
19672         struct alc_spec *spec = codec->spec;
19673
19674         spec->autocfg.hp_pins[0] = 0x16;
19675         spec->autocfg.speaker_pins[0] = 0x14;
19676         spec->autocfg.speaker_pins[1] = 0x15;
19677         spec->autocfg.num_inputs = 2;
19678         spec->autocfg.inputs[0].pin = 0x18;
19679         spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
19680         spec->autocfg.inputs[1].pin = 0x19;
19681         spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
19682 }
19683
19684 static void alc680_unsol_event(struct hda_codec *codec,
19685                                            unsigned int res)
19686 {
19687         if ((res >> 26) == ALC880_HP_EVENT)
19688                 alc_automute_amp(codec);
19689         if ((res >> 26) == ALC880_MIC_EVENT)
19690                 alc680_rec_autoswitch(codec);
19691 }
19692
19693 static void alc680_inithook(struct hda_codec *codec)
19694 {
19695         alc_automute_amp(codec);
19696         alc680_rec_autoswitch(codec);
19697 }
19698
19699 /* create input playback/capture controls for the given pin */
19700 static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
19701                                     const char *ctlname, int idx)
19702 {
19703         hda_nid_t dac;
19704         int err;
19705
19706         switch (nid) {
19707         case 0x14:
19708                 dac = 0x02;
19709                 break;
19710         case 0x15:
19711                 dac = 0x03;
19712                 break;
19713         case 0x16:
19714                 dac = 0x04;
19715                 break;
19716         default:
19717                 return 0;
19718         }
19719         if (spec->multiout.dac_nids[0] != dac &&
19720             spec->multiout.dac_nids[1] != dac) {
19721                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
19722                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
19723                                                       HDA_OUTPUT));
19724                 if (err < 0)
19725                         return err;
19726
19727                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
19728                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
19729
19730                 if (err < 0)
19731                         return err;
19732                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19733         }
19734
19735         return 0;
19736 }
19737
19738 /* add playback controls from the parsed DAC table */
19739 static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
19740                                              const struct auto_pin_cfg *cfg)
19741 {
19742         hda_nid_t nid;
19743         int err;
19744
19745         spec->multiout.dac_nids = spec->private_dac_nids;
19746
19747         nid = cfg->line_out_pins[0];
19748         if (nid) {
19749                 const char *name;
19750                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19751                         name = "Speaker";
19752                 else
19753                         name = "Front";
19754                 err = alc680_new_analog_output(spec, nid, name, 0);
19755                 if (err < 0)
19756                         return err;
19757         }
19758
19759         nid = cfg->speaker_pins[0];
19760         if (nid) {
19761                 err = alc680_new_analog_output(spec, nid, "Speaker", 0);
19762                 if (err < 0)
19763                         return err;
19764         }
19765         nid = cfg->hp_pins[0];
19766         if (nid) {
19767                 err = alc680_new_analog_output(spec, nid, "Headphone", 0);
19768                 if (err < 0)
19769                         return err;
19770         }
19771
19772         return 0;
19773 }
19774
19775 static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
19776                                               hda_nid_t nid, int pin_type)
19777 {
19778         alc_set_pin_output(codec, nid, pin_type);
19779 }
19780
19781 static void alc680_auto_init_multi_out(struct hda_codec *codec)
19782 {
19783         struct alc_spec *spec = codec->spec;
19784         hda_nid_t nid = spec->autocfg.line_out_pins[0];
19785         if (nid) {
19786                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
19787                 alc680_auto_set_output_and_unmute(codec, nid, pin_type);
19788         }
19789 }
19790
19791 static void alc680_auto_init_hp_out(struct hda_codec *codec)
19792 {
19793         struct alc_spec *spec = codec->spec;
19794         hda_nid_t pin;
19795
19796         pin = spec->autocfg.hp_pins[0];
19797         if (pin)
19798                 alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
19799         pin = spec->autocfg.speaker_pins[0];
19800         if (pin)
19801                 alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
19802 }
19803
19804 /* pcm configuration: identical with ALC880 */
19805 #define alc680_pcm_analog_playback      alc880_pcm_analog_playback
19806 #define alc680_pcm_analog_capture       alc880_pcm_analog_capture
19807 #define alc680_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
19808 #define alc680_pcm_digital_playback     alc880_pcm_digital_playback
19809 #define alc680_pcm_digital_capture      alc880_pcm_digital_capture
19810
19811 /*
19812  * BIOS auto configuration
19813  */
19814 static int alc680_parse_auto_config(struct hda_codec *codec)
19815 {
19816         struct alc_spec *spec = codec->spec;
19817         int err;
19818         static hda_nid_t alc680_ignore[] = { 0 };
19819
19820         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19821                                            alc680_ignore);
19822         if (err < 0)
19823                 return err;
19824
19825         if (!spec->autocfg.line_outs) {
19826                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
19827                         spec->multiout.max_channels = 2;
19828                         spec->no_analog = 1;
19829                         goto dig_only;
19830                 }
19831                 return 0; /* can't find valid BIOS pin config */
19832         }
19833         err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
19834         if (err < 0)
19835                 return err;
19836
19837         spec->multiout.max_channels = 2;
19838
19839  dig_only:
19840         /* digital only support output */
19841         alc_auto_parse_digital(codec);
19842         if (spec->kctls.list)
19843                 add_mixer(spec, spec->kctls.list);
19844
19845         add_verb(spec, alc680_init_verbs);
19846
19847         err = alc_auto_add_mic_boost(codec);
19848         if (err < 0)
19849                 return err;
19850
19851         return 1;
19852 }
19853
19854 #define alc680_auto_init_analog_input   alc882_auto_init_analog_input
19855
19856 /* init callback for auto-configuration model -- overriding the default init */
19857 static void alc680_auto_init(struct hda_codec *codec)
19858 {
19859         struct alc_spec *spec = codec->spec;
19860         alc680_auto_init_multi_out(codec);
19861         alc680_auto_init_hp_out(codec);
19862         alc680_auto_init_analog_input(codec);
19863         alc_auto_init_digital(codec);
19864         if (spec->unsol_event)
19865                 alc_inithook(codec);
19866 }
19867
19868 /*
19869  * configuration and preset
19870  */
19871 static const char *alc680_models[ALC680_MODEL_LAST] = {
19872         [ALC680_BASE]           = "base",
19873         [ALC680_AUTO]           = "auto",
19874 };
19875
19876 static struct snd_pci_quirk alc680_cfg_tbl[] = {
19877         SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
19878         {}
19879 };
19880
19881 static struct alc_config_preset alc680_presets[] = {
19882         [ALC680_BASE] = {
19883                 .mixers = { alc680_base_mixer },
19884                 .cap_mixer =  alc680_master_capture_mixer,
19885                 .init_verbs = { alc680_init_verbs },
19886                 .num_dacs = ARRAY_SIZE(alc680_dac_nids),
19887                 .dac_nids = alc680_dac_nids,
19888                 .dig_out_nid = ALC680_DIGOUT_NID,
19889                 .num_channel_mode = ARRAY_SIZE(alc680_modes),
19890                 .channel_mode = alc680_modes,
19891                 .unsol_event = alc680_unsol_event,
19892                 .setup = alc680_base_setup,
19893                 .init_hook = alc680_inithook,
19894
19895         },
19896 };
19897
19898 static int patch_alc680(struct hda_codec *codec)
19899 {
19900         struct alc_spec *spec;
19901         int board_config;
19902         int err;
19903
19904         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19905         if (spec == NULL)
19906                 return -ENOMEM;
19907
19908         codec->spec = spec;
19909
19910         board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
19911                                                   alc680_models,
19912                                                   alc680_cfg_tbl);
19913
19914         if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
19915                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19916                        codec->chip_name);
19917                 board_config = ALC680_AUTO;
19918         }
19919
19920         if (board_config == ALC680_AUTO) {
19921                 /* automatic parse from the BIOS config */
19922                 err = alc680_parse_auto_config(codec);
19923                 if (err < 0) {
19924                         alc_free(codec);
19925                         return err;
19926                 } else if (!err) {
19927                         printk(KERN_INFO
19928                                "hda_codec: Cannot set up configuration "
19929                                "from BIOS.  Using base mode...\n");
19930                         board_config = ALC680_BASE;
19931                 }
19932         }
19933
19934         if (board_config != ALC680_AUTO)
19935                 setup_preset(codec, &alc680_presets[board_config]);
19936
19937         spec->stream_analog_playback = &alc680_pcm_analog_playback;
19938         spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
19939         spec->stream_digital_playback = &alc680_pcm_digital_playback;
19940         spec->stream_digital_capture = &alc680_pcm_digital_capture;
19941
19942         if (!spec->adc_nids) {
19943                 spec->adc_nids = alc680_adc_nids;
19944                 spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
19945         }
19946
19947         if (!spec->cap_mixer)
19948                 set_capture_mixer(codec);
19949
19950         spec->vmaster_nid = 0x02;
19951
19952         codec->patch_ops = alc_patch_ops;
19953         if (board_config == ALC680_AUTO)
19954                 spec->init_hook = alc680_auto_init;
19955
19956         return 0;
19957 }
19958
19959 /*
19960  * patch entries
19961  */
19962 static struct hda_codec_preset snd_hda_preset_realtek[] = {
19963         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
19964         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
19965         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
19966         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
19967         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
19968         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
19969         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
19970         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
19971         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
19972           .patch = patch_alc861 },
19973         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
19974         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
19975         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
19976         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
19977           .patch = patch_alc882 },
19978         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
19979           .patch = patch_alc662 },
19980         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
19981         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
19982         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
19983         { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
19984         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
19985         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
19986         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
19987         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
19988           .patch = patch_alc882 },
19989         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
19990           .patch = patch_alc882 },
19991         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
19992         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 },
19993         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
19994           .patch = patch_alc882 },
19995         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
19996         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
19997         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
19998         {} /* terminator */
19999 };
20000
20001 MODULE_ALIAS("snd-hda-codec-id:10ec*");
20002
20003 MODULE_LICENSE("GPL");
20004 MODULE_DESCRIPTION("Realtek HD-audio codec");
20005
20006 static struct hda_codec_preset_list realtek_list = {
20007         .preset = snd_hda_preset_realtek,
20008         .owner = THIS_MODULE,
20009 };
20010
20011 static int __init patch_realtek_init(void)
20012 {
20013         return snd_hda_add_codec_preset(&realtek_list);
20014 }
20015
20016 static void __exit patch_realtek_exit(void)
20017 {
20018         snd_hda_delete_codec_preset(&realtek_list);
20019 }
20020
20021 module_init(patch_realtek_init)
20022 module_exit(patch_realtek_exit)